//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS CleanRooms service.
///
/// Welcome to the Clean Rooms API Reference. Clean Rooms is an Amazon Web Services service that helps multiple parties to join their data together in a secure collaboration workspace. In the collaboration, members who can run queries and jobs and receive results can get insights into the collective datasets without either party getting access to the other party's raw data. To learn more about Clean Rooms concepts, procedures, and best practices, see the Clean Rooms User Guide. To learn more about SQL commands, functions, and conditions supported in Clean Rooms, see the Clean Rooms SQL Reference.
public struct CleanRooms: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the CleanRooms client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "CleanRooms",
            serviceIdentifier: "cleanrooms",
            serviceProtocol: .restjson,
            apiVersion: "2022-02-17",
            endpoint: endpoint,
            variantEndpoints: Self.variantEndpoints,
            errorType: CleanRoomsErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }




    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.dualstack]: .init(endpoints: [
            "ap-northeast-1": "cleanrooms.ap-northeast-1.api.aws",
            "ap-northeast-2": "cleanrooms.ap-northeast-2.api.aws",
            "ap-southeast-1": "cleanrooms.ap-southeast-1.api.aws",
            "ap-southeast-2": "cleanrooms.ap-southeast-2.api.aws",
            "eu-central-1": "cleanrooms.eu-central-1.api.aws",
            "eu-north-1": "cleanrooms.eu-north-1.api.aws",
            "eu-west-1": "cleanrooms.eu-west-1.api.aws",
            "eu-west-2": "cleanrooms.eu-west-2.api.aws",
            "us-east-1": "cleanrooms.us-east-1.api.aws",
            "us-east-2": "cleanrooms.us-east-2.api.aws",
            "us-west-2": "cleanrooms.us-west-2.api.aws"
        ]),
        [.dualstack, .fips]: .init(endpoints: [
            "us-east-1": "cleanrooms-fips.us-east-1.api.aws",
            "us-east-2": "cleanrooms-fips.us-east-2.api.aws",
            "us-west-2": "cleanrooms-fips.us-west-2.api.aws"
        ]),
        [.fips]: .init(endpoints: [
            "us-east-1": "cleanrooms-fips.us-east-1.amazonaws.com",
            "us-east-2": "cleanrooms-fips.us-east-2.amazonaws.com",
            "us-west-2": "cleanrooms-fips.us-west-2.amazonaws.com"
        ])
    ]}

    // MARK: API Calls

    /// Retrieves multiple analysis templates within a collaboration by their Amazon Resource Names (ARNs).
    @Sendable
    @inlinable
    public func batchGetCollaborationAnalysisTemplate(_ input: BatchGetCollaborationAnalysisTemplateInput, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchGetCollaborationAnalysisTemplateOutput {
        try await self.client.execute(
            operation: "BatchGetCollaborationAnalysisTemplate", 
            path: "/collaborations/{collaborationIdentifier}/batch-analysistemplates", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves multiple analysis templates within a collaboration by their Amazon Resource Names (ARNs).
    ///
    /// Parameters:
    ///   - analysisTemplateArns: The Amazon Resource Name (ARN) associated with the analysis template within a collaboration.
    ///   - collaborationIdentifier: A unique identifier for the collaboration that the analysis templates belong to. Currently accepts collaboration ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchGetCollaborationAnalysisTemplate(
        analysisTemplateArns: [String],
        collaborationIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchGetCollaborationAnalysisTemplateOutput {
        let input = BatchGetCollaborationAnalysisTemplateInput(
            analysisTemplateArns: analysisTemplateArns, 
            collaborationIdentifier: collaborationIdentifier
        )
        return try await self.batchGetCollaborationAnalysisTemplate(input, logger: logger)
    }

    /// Retrieves multiple schemas by their identifiers.
    @Sendable
    @inlinable
    public func batchGetSchema(_ input: BatchGetSchemaInput, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchGetSchemaOutput {
        try await self.client.execute(
            operation: "BatchGetSchema", 
            path: "/collaborations/{collaborationIdentifier}/batch-schema", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves multiple schemas by their identifiers.
    ///
    /// Parameters:
    ///   - collaborationIdentifier: A unique identifier for the collaboration that the schemas belong to. Currently accepts collaboration ID.
    ///   - names: The names for the schema objects to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchGetSchema(
        collaborationIdentifier: String,
        names: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchGetSchemaOutput {
        let input = BatchGetSchemaInput(
            collaborationIdentifier: collaborationIdentifier, 
            names: names
        )
        return try await self.batchGetSchema(input, logger: logger)
    }

    /// Retrieves multiple analysis rule schemas.
    @Sendable
    @inlinable
    public func batchGetSchemaAnalysisRule(_ input: BatchGetSchemaAnalysisRuleInput, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchGetSchemaAnalysisRuleOutput {
        try await self.client.execute(
            operation: "BatchGetSchemaAnalysisRule", 
            path: "/collaborations/{collaborationIdentifier}/batch-schema-analysis-rule", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves multiple analysis rule schemas.
    ///
    /// Parameters:
    ///   - collaborationIdentifier: The unique identifier of the collaboration that contains the schema analysis rule.
    ///   - schemaAnalysisRuleRequests: The information that's necessary to retrieve a schema analysis rule.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchGetSchemaAnalysisRule(
        collaborationIdentifier: String,
        schemaAnalysisRuleRequests: [SchemaAnalysisRuleRequest],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchGetSchemaAnalysisRuleOutput {
        let input = BatchGetSchemaAnalysisRuleInput(
            collaborationIdentifier: collaborationIdentifier, 
            schemaAnalysisRuleRequests: schemaAnalysisRuleRequests
        )
        return try await self.batchGetSchemaAnalysisRule(input, logger: logger)
    }

    /// Creates a new analysis template.
    @Sendable
    @inlinable
    public func createAnalysisTemplate(_ input: CreateAnalysisTemplateInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAnalysisTemplateOutput {
        try await self.client.execute(
            operation: "CreateAnalysisTemplate", 
            path: "/memberships/{membershipIdentifier}/analysistemplates", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new analysis template.
    ///
    /// Parameters:
    ///   - analysisParameters: The parameters of the analysis template.
    ///   - description: The description of the analysis template.
    ///   - format: The format of the analysis template.
    ///   - membershipIdentifier: The identifier for a membership resource.
    ///   - name: The name of the analysis template.
    ///   - schema: 
    ///   - source: The information in the analysis template. Currently supports text, the query text for the analysis template.
    ///   - tags: An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createAnalysisTemplate(
        analysisParameters: [AnalysisParameter]? = nil,
        description: String? = nil,
        format: AnalysisFormat,
        membershipIdentifier: String,
        name: String,
        schema: AnalysisSchema? = nil,
        source: AnalysisSource,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAnalysisTemplateOutput {
        let input = CreateAnalysisTemplateInput(
            analysisParameters: analysisParameters, 
            description: description, 
            format: format, 
            membershipIdentifier: membershipIdentifier, 
            name: name, 
            schema: schema, 
            source: source, 
            tags: tags
        )
        return try await self.createAnalysisTemplate(input, logger: logger)
    }

    /// Creates a new collaboration.
    @Sendable
    @inlinable
    public func createCollaboration(_ input: CreateCollaborationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateCollaborationOutput {
        try await self.client.execute(
            operation: "CreateCollaboration", 
            path: "/collaborations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new collaboration.
    ///
    /// Parameters:
    ///   - analyticsEngine:  The analytics engine.
    ///   - creatorDisplayName: The display name of the collaboration creator.
    ///   - creatorMemberAbilities: The abilities granted to the collaboration creator.
    ///   - creatorMLMemberAbilities: The ML abilities granted to the collaboration creator.
    ///   - creatorPaymentConfiguration: The collaboration creator's payment responsibilities set by the collaboration creator.  If the collaboration creator hasn't specified anyone as the member paying for query compute costs, then the member who can query is the default payer.
    ///   - dataEncryptionMetadata: The settings for client-side encryption with Cryptographic Computing for Clean Rooms.
    ///   - description: A description of the collaboration provided by the collaboration owner.
    ///   - jobLogStatus: Specifies whether job logs are enabled for this collaboration.  When ENABLED, Clean Rooms logs details about jobs run within this collaboration; those logs can be viewed in Amazon CloudWatch Logs. The default value is DISABLED.
    ///   - members: A list of initial members, not including the creator. This list is immutable.
    ///   - name: The display name for a collaboration.
    ///   - queryLogStatus: An indicator as to whether query logging has been enabled or disabled for the collaboration. When ENABLED, Clean Rooms logs details about queries run within this collaboration and those logs can be viewed in Amazon CloudWatch Logs. The default value is DISABLED.
    ///   - tags: An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createCollaboration(
        analyticsEngine: AnalyticsEngine? = nil,
        creatorDisplayName: String,
        creatorMemberAbilities: [MemberAbility],
        creatorMLMemberAbilities: MLMemberAbilities? = nil,
        creatorPaymentConfiguration: PaymentConfiguration? = nil,
        dataEncryptionMetadata: DataEncryptionMetadata? = nil,
        description: String,
        jobLogStatus: CollaborationJobLogStatus? = nil,
        members: [MemberSpecification],
        name: String,
        queryLogStatus: CollaborationQueryLogStatus,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateCollaborationOutput {
        let input = CreateCollaborationInput(
            analyticsEngine: analyticsEngine, 
            creatorDisplayName: creatorDisplayName, 
            creatorMemberAbilities: creatorMemberAbilities, 
            creatorMLMemberAbilities: creatorMLMemberAbilities, 
            creatorPaymentConfiguration: creatorPaymentConfiguration, 
            dataEncryptionMetadata: dataEncryptionMetadata, 
            description: description, 
            jobLogStatus: jobLogStatus, 
            members: members, 
            name: name, 
            queryLogStatus: queryLogStatus, 
            tags: tags
        )
        return try await self.createCollaboration(input, logger: logger)
    }

    /// Provides the details necessary to create a configured audience model association.
    @Sendable
    @inlinable
    public func createConfiguredAudienceModelAssociation(_ input: CreateConfiguredAudienceModelAssociationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateConfiguredAudienceModelAssociationOutput {
        try await self.client.execute(
            operation: "CreateConfiguredAudienceModelAssociation", 
            path: "/memberships/{membershipIdentifier}/configuredaudiencemodelassociations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides the details necessary to create a configured audience model association.
    ///
    /// Parameters:
    ///   - configuredAudienceModelArn: A unique identifier for the configured audience model that you want to associate.
    ///   - configuredAudienceModelAssociationName: The name of the configured audience model association.
    ///   - description: A description of the configured audience model association.
    ///   - manageResourcePolicies: When TRUE, indicates that the resource policy for the configured audience model resource being associated is configured for Clean Rooms to manage permissions related to the given collaboration. When FALSE, indicates that the configured audience model resource owner will manage permissions related to the given collaboration. Setting this to TRUE requires you to have permissions to create, update, and delete the resource policy for the cleanrooms-ml resource when you call the DeleteConfiguredAudienceModelAssociation resource. In addition, if you are the collaboration creator and specify TRUE, you must have the same permissions when you call the DeleteMember and DeleteCollaboration APIs.
    ///   - membershipIdentifier: A unique identifier for one of your memberships for a collaboration. The configured audience model is associated to the collaboration that this membership belongs to. Accepts a membership ID.
    ///   - tags: An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createConfiguredAudienceModelAssociation(
        configuredAudienceModelArn: String,
        configuredAudienceModelAssociationName: String,
        description: String? = nil,
        manageResourcePolicies: Bool,
        membershipIdentifier: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateConfiguredAudienceModelAssociationOutput {
        let input = CreateConfiguredAudienceModelAssociationInput(
            configuredAudienceModelArn: configuredAudienceModelArn, 
            configuredAudienceModelAssociationName: configuredAudienceModelAssociationName, 
            description: description, 
            manageResourcePolicies: manageResourcePolicies, 
            membershipIdentifier: membershipIdentifier, 
            tags: tags
        )
        return try await self.createConfiguredAudienceModelAssociation(input, logger: logger)
    }

    /// Creates a new configured table resource.
    @Sendable
    @inlinable
    public func createConfiguredTable(_ input: CreateConfiguredTableInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateConfiguredTableOutput {
        try await self.client.execute(
            operation: "CreateConfiguredTable", 
            path: "/configuredTables", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new configured table resource.
    ///
    /// Parameters:
    ///   - allowedColumns: The columns of the underlying table that can be used by collaborations or analysis rules.
    ///   - analysisMethod: The analysis method allowed for the configured tables.  DIRECT_QUERY allows SQL queries to be run directly on this table.  DIRECT_JOB allows PySpark jobs to be run directly on this table.  MULTIPLE allows both SQL queries and PySpark jobs to be run directly on this table.
    ///   - description: A description for the configured table.
    ///   - name: The name of the configured table.
    ///   - selectedAnalysisMethods:  The analysis methods to enable for the configured table. When configured, you must specify at least two analysis methods.
    ///   - tableReference: A reference to the table being configured.
    ///   - tags: An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createConfiguredTable(
        allowedColumns: [String],
        analysisMethod: AnalysisMethod,
        description: String? = nil,
        name: String,
        selectedAnalysisMethods: [SelectedAnalysisMethod]? = nil,
        tableReference: TableReference,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateConfiguredTableOutput {
        let input = CreateConfiguredTableInput(
            allowedColumns: allowedColumns, 
            analysisMethod: analysisMethod, 
            description: description, 
            name: name, 
            selectedAnalysisMethods: selectedAnalysisMethods, 
            tableReference: tableReference, 
            tags: tags
        )
        return try await self.createConfiguredTable(input, logger: logger)
    }

    /// Creates a new analysis rule for a configured table. Currently, only one analysis rule can be created for a given configured table.
    @Sendable
    @inlinable
    public func createConfiguredTableAnalysisRule(_ input: CreateConfiguredTableAnalysisRuleInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateConfiguredTableAnalysisRuleOutput {
        try await self.client.execute(
            operation: "CreateConfiguredTableAnalysisRule", 
            path: "/configuredTables/{configuredTableIdentifier}/analysisRule", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new analysis rule for a configured table. Currently, only one analysis rule can be created for a given configured table.
    ///
    /// Parameters:
    ///   - analysisRulePolicy: The analysis rule policy that was created for the configured table.
    ///   - analysisRuleType: The type of analysis rule.
    ///   - configuredTableIdentifier: The identifier for the configured table to create the analysis rule for. Currently accepts the configured table ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func createConfiguredTableAnalysisRule(
        analysisRulePolicy: ConfiguredTableAnalysisRulePolicy,
        analysisRuleType: ConfiguredTableAnalysisRuleType,
        configuredTableIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateConfiguredTableAnalysisRuleOutput {
        let input = CreateConfiguredTableAnalysisRuleInput(
            analysisRulePolicy: analysisRulePolicy, 
            analysisRuleType: analysisRuleType, 
            configuredTableIdentifier: configuredTableIdentifier
        )
        return try await self.createConfiguredTableAnalysisRule(input, logger: logger)
    }

    /// Creates a configured table association. A configured table association links a configured table with a collaboration.
    @Sendable
    @inlinable
    public func createConfiguredTableAssociation(_ input: CreateConfiguredTableAssociationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateConfiguredTableAssociationOutput {
        try await self.client.execute(
            operation: "CreateConfiguredTableAssociation", 
            path: "/memberships/{membershipIdentifier}/configuredTableAssociations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a configured table association. A configured table association links a configured table with a collaboration.
    ///
    /// Parameters:
    ///   - configuredTableIdentifier: A unique identifier for the configured table to be associated to. Currently accepts a configured table ID.
    ///   - description: A description for the configured table association.
    ///   - membershipIdentifier: A unique identifier for one of your memberships for a collaboration. The configured table is associated to the collaboration that this membership belongs to. Currently accepts a membership ID.
    ///   - name: The name of the configured table association. This name is used to query the underlying configured table.
    ///   - roleArn: The service will assume this role to access catalog metadata and query the table.
    ///   - tags: An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createConfiguredTableAssociation(
        configuredTableIdentifier: String,
        description: String? = nil,
        membershipIdentifier: String,
        name: String,
        roleArn: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateConfiguredTableAssociationOutput {
        let input = CreateConfiguredTableAssociationInput(
            configuredTableIdentifier: configuredTableIdentifier, 
            description: description, 
            membershipIdentifier: membershipIdentifier, 
            name: name, 
            roleArn: roleArn, 
            tags: tags
        )
        return try await self.createConfiguredTableAssociation(input, logger: logger)
    }

    ///  Creates a new analysis rule for an associated configured table.
    @Sendable
    @inlinable
    public func createConfiguredTableAssociationAnalysisRule(_ input: CreateConfiguredTableAssociationAnalysisRuleInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateConfiguredTableAssociationAnalysisRuleOutput {
        try await self.client.execute(
            operation: "CreateConfiguredTableAssociationAnalysisRule", 
            path: "/memberships/{membershipIdentifier}/configuredTableAssociations/{configuredTableAssociationIdentifier}/analysisRule", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Creates a new analysis rule for an associated configured table.
    ///
    /// Parameters:
    ///   - analysisRulePolicy: The analysis rule policy that was created for the configured table association.
    ///   - analysisRuleType:  The type of analysis rule.
    ///   - configuredTableAssociationIdentifier:  The unique ID for the configured table association. Currently accepts the configured table association ID.
    ///   - membershipIdentifier:  A unique identifier for the membership that the configured table association belongs to. Currently accepts the membership ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func createConfiguredTableAssociationAnalysisRule(
        analysisRulePolicy: ConfiguredTableAssociationAnalysisRulePolicy,
        analysisRuleType: ConfiguredTableAssociationAnalysisRuleType,
        configuredTableAssociationIdentifier: String,
        membershipIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateConfiguredTableAssociationAnalysisRuleOutput {
        let input = CreateConfiguredTableAssociationAnalysisRuleInput(
            analysisRulePolicy: analysisRulePolicy, 
            analysisRuleType: analysisRuleType, 
            configuredTableAssociationIdentifier: configuredTableAssociationIdentifier, 
            membershipIdentifier: membershipIdentifier
        )
        return try await self.createConfiguredTableAssociationAnalysisRule(input, logger: logger)
    }

    /// Creates an ID mapping table.
    @Sendable
    @inlinable
    public func createIdMappingTable(_ input: CreateIdMappingTableInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateIdMappingTableOutput {
        try await self.client.execute(
            operation: "CreateIdMappingTable", 
            path: "/memberships/{membershipIdentifier}/idmappingtables", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an ID mapping table.
    ///
    /// Parameters:
    ///   - description: A description of the ID mapping table.
    ///   - inputReferenceConfig: The input reference configuration needed to create the ID mapping table.
    ///   - kmsKeyArn: The Amazon Resource Name (ARN) of the Amazon Web Services KMS key. This value is used to encrypt the mapping table data that is stored by Clean Rooms.
    ///   - membershipIdentifier: The unique identifier of the membership that contains the ID mapping table.
    ///   - name: A name for the ID mapping table.
    ///   - tags: An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createIdMappingTable(
        description: String? = nil,
        inputReferenceConfig: IdMappingTableInputReferenceConfig,
        kmsKeyArn: String? = nil,
        membershipIdentifier: String,
        name: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateIdMappingTableOutput {
        let input = CreateIdMappingTableInput(
            description: description, 
            inputReferenceConfig: inputReferenceConfig, 
            kmsKeyArn: kmsKeyArn, 
            membershipIdentifier: membershipIdentifier, 
            name: name, 
            tags: tags
        )
        return try await self.createIdMappingTable(input, logger: logger)
    }

    /// Creates an ID namespace association.
    @Sendable
    @inlinable
    public func createIdNamespaceAssociation(_ input: CreateIdNamespaceAssociationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateIdNamespaceAssociationOutput {
        try await self.client.execute(
            operation: "CreateIdNamespaceAssociation", 
            path: "/memberships/{membershipIdentifier}/idnamespaceassociations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an ID namespace association.
    ///
    /// Parameters:
    ///   - description: The description of the ID namespace association.
    ///   - idMappingConfig: The configuration settings for the ID mapping table.
    ///   - inputReferenceConfig: The input reference configuration needed to create the ID namespace association.
    ///   - membershipIdentifier: The unique identifier of the membership that contains the ID namespace association.
    ///   - name: The name for the ID namespace association.
    ///   - tags: An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createIdNamespaceAssociation(
        description: String? = nil,
        idMappingConfig: IdMappingConfig? = nil,
        inputReferenceConfig: IdNamespaceAssociationInputReferenceConfig,
        membershipIdentifier: String,
        name: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateIdNamespaceAssociationOutput {
        let input = CreateIdNamespaceAssociationInput(
            description: description, 
            idMappingConfig: idMappingConfig, 
            inputReferenceConfig: inputReferenceConfig, 
            membershipIdentifier: membershipIdentifier, 
            name: name, 
            tags: tags
        )
        return try await self.createIdNamespaceAssociation(input, logger: logger)
    }

    /// Creates a membership for a specific collaboration identifier and joins the collaboration.
    @Sendable
    @inlinable
    public func createMembership(_ input: CreateMembershipInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateMembershipOutput {
        try await self.client.execute(
            operation: "CreateMembership", 
            path: "/memberships", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a membership for a specific collaboration identifier and joins the collaboration.
    ///
    /// Parameters:
    ///   - collaborationIdentifier: The unique ID for the associated collaboration.
    ///   - defaultJobResultConfiguration: The default job result configuration that determines how job results are protected and managed within this membership. This configuration applies to all jobs.
    ///   - defaultResultConfiguration: The default protected query result configuration as specified by the member who can receive results.
    ///   - jobLogStatus: An indicator as to whether job logging has been enabled or disabled for the collaboration.  When ENABLED, Clean Rooms logs details about jobs run within this collaboration and those logs can be viewed in Amazon CloudWatch Logs. The default value is DISABLED.
    ///   - paymentConfiguration: The payment responsibilities accepted by the collaboration member. Not required if the collaboration member has the member ability to run queries.  Required if the collaboration member doesn't have the member ability to run queries but is configured as a payer by the collaboration creator.
    ///   - queryLogStatus: An indicator as to whether query logging has been enabled or disabled for the membership. When ENABLED, Clean Rooms logs details about queries run within this collaboration and those logs can be viewed in Amazon CloudWatch Logs. The default value is DISABLED.
    ///   - tags: An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createMembership(
        collaborationIdentifier: String,
        defaultJobResultConfiguration: MembershipProtectedJobResultConfiguration? = nil,
        defaultResultConfiguration: MembershipProtectedQueryResultConfiguration? = nil,
        jobLogStatus: MembershipJobLogStatus? = nil,
        paymentConfiguration: MembershipPaymentConfiguration? = nil,
        queryLogStatus: MembershipQueryLogStatus,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateMembershipOutput {
        let input = CreateMembershipInput(
            collaborationIdentifier: collaborationIdentifier, 
            defaultJobResultConfiguration: defaultJobResultConfiguration, 
            defaultResultConfiguration: defaultResultConfiguration, 
            jobLogStatus: jobLogStatus, 
            paymentConfiguration: paymentConfiguration, 
            queryLogStatus: queryLogStatus, 
            tags: tags
        )
        return try await self.createMembership(input, logger: logger)
    }

    /// Creates a privacy budget template for a specified membership. Each membership can have only one privacy budget template, but it can be deleted and recreated. If you need to change the privacy budget template for a membership, use the UpdatePrivacyBudgetTemplate operation.
    @Sendable
    @inlinable
    public func createPrivacyBudgetTemplate(_ input: CreatePrivacyBudgetTemplateInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreatePrivacyBudgetTemplateOutput {
        try await self.client.execute(
            operation: "CreatePrivacyBudgetTemplate", 
            path: "/memberships/{membershipIdentifier}/privacybudgettemplates", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a privacy budget template for a specified membership. Each membership can have only one privacy budget template, but it can be deleted and recreated. If you need to change the privacy budget template for a membership, use the UpdatePrivacyBudgetTemplate operation.
    ///
    /// Parameters:
    ///   - autoRefresh: How often the privacy budget refreshes.  If you plan to regularly bring new data into the collaboration, you can use CALENDAR_MONTH to automatically get a new privacy budget for the collaboration every calendar month. Choosing this option allows arbitrary amounts of information to be revealed about rows of the data when repeatedly queries across refreshes. Avoid choosing this if the same rows will be repeatedly queried between privacy budget refreshes.
    ///   - membershipIdentifier: A unique identifier for one of your memberships for a collaboration. The privacy budget template is created in the collaboration that this membership belongs to. Accepts a membership ID.
    ///   - parameters: Specifies your parameters for the privacy budget template.
    ///   - privacyBudgetType: Specifies the type of the privacy budget template.
    ///   - tags: An optional label that you can assign to a resource when you create it. Each tag consists of a key and an optional value, both of which you define. When you use tagging, you can also use tag-based access control in IAM policies to control access to this resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createPrivacyBudgetTemplate(
        autoRefresh: PrivacyBudgetTemplateAutoRefresh,
        membershipIdentifier: String,
        parameters: PrivacyBudgetTemplateParametersInput,
        privacyBudgetType: PrivacyBudgetType,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreatePrivacyBudgetTemplateOutput {
        let input = CreatePrivacyBudgetTemplateInput(
            autoRefresh: autoRefresh, 
            membershipIdentifier: membershipIdentifier, 
            parameters: parameters, 
            privacyBudgetType: privacyBudgetType, 
            tags: tags
        )
        return try await self.createPrivacyBudgetTemplate(input, logger: logger)
    }

    /// Deletes an analysis template.
    @Sendable
    @inlinable
    public func deleteAnalysisTemplate(_ input: DeleteAnalysisTemplateInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAnalysisTemplateOutput {
        try await self.client.execute(
            operation: "DeleteAnalysisTemplate", 
            path: "/memberships/{membershipIdentifier}/analysistemplates/{analysisTemplateIdentifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an analysis template.
    ///
    /// Parameters:
    ///   - analysisTemplateIdentifier: The identifier for the analysis template resource.
    ///   - membershipIdentifier: The identifier for a membership resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAnalysisTemplate(
        analysisTemplateIdentifier: String,
        membershipIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAnalysisTemplateOutput {
        let input = DeleteAnalysisTemplateInput(
            analysisTemplateIdentifier: analysisTemplateIdentifier, 
            membershipIdentifier: membershipIdentifier
        )
        return try await self.deleteAnalysisTemplate(input, logger: logger)
    }

    /// Deletes a collaboration. It can only be called by the collaboration owner.
    @Sendable
    @inlinable
    public func deleteCollaboration(_ input: DeleteCollaborationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteCollaborationOutput {
        try await self.client.execute(
            operation: "DeleteCollaboration", 
            path: "/collaborations/{collaborationIdentifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a collaboration. It can only be called by the collaboration owner.
    ///
    /// Parameters:
    ///   - collaborationIdentifier: The identifier for the collaboration.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteCollaboration(
        collaborationIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteCollaborationOutput {
        let input = DeleteCollaborationInput(
            collaborationIdentifier: collaborationIdentifier
        )
        return try await self.deleteCollaboration(input, logger: logger)
    }

    /// Provides the information necessary to delete a configured audience model association.
    @Sendable
    @inlinable
    public func deleteConfiguredAudienceModelAssociation(_ input: DeleteConfiguredAudienceModelAssociationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteConfiguredAudienceModelAssociationOutput {
        try await self.client.execute(
            operation: "DeleteConfiguredAudienceModelAssociation", 
            path: "/memberships/{membershipIdentifier}/configuredaudiencemodelassociations/{configuredAudienceModelAssociationIdentifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides the information necessary to delete a configured audience model association.
    ///
    /// Parameters:
    ///   - configuredAudienceModelAssociationIdentifier: A unique identifier of the configured audience model association that you want to delete.
    ///   - membershipIdentifier: A unique identifier of the membership that contains the audience model association that you want to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteConfiguredAudienceModelAssociation(
        configuredAudienceModelAssociationIdentifier: String,
        membershipIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteConfiguredAudienceModelAssociationOutput {
        let input = DeleteConfiguredAudienceModelAssociationInput(
            configuredAudienceModelAssociationIdentifier: configuredAudienceModelAssociationIdentifier, 
            membershipIdentifier: membershipIdentifier
        )
        return try await self.deleteConfiguredAudienceModelAssociation(input, logger: logger)
    }

    /// Deletes a configured table.
    @Sendable
    @inlinable
    public func deleteConfiguredTable(_ input: DeleteConfiguredTableInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteConfiguredTableOutput {
        try await self.client.execute(
            operation: "DeleteConfiguredTable", 
            path: "/configuredTables/{configuredTableIdentifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a configured table.
    ///
    /// Parameters:
    ///   - configuredTableIdentifier: The unique ID for the configured table to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteConfiguredTable(
        configuredTableIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteConfiguredTableOutput {
        let input = DeleteConfiguredTableInput(
            configuredTableIdentifier: configuredTableIdentifier
        )
        return try await self.deleteConfiguredTable(input, logger: logger)
    }

    /// Deletes a configured table analysis rule.
    @Sendable
    @inlinable
    public func deleteConfiguredTableAnalysisRule(_ input: DeleteConfiguredTableAnalysisRuleInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteConfiguredTableAnalysisRuleOutput {
        try await self.client.execute(
            operation: "DeleteConfiguredTableAnalysisRule", 
            path: "/configuredTables/{configuredTableIdentifier}/analysisRule/{analysisRuleType}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a configured table analysis rule.
    ///
    /// Parameters:
    ///   - analysisRuleType: The analysis rule type to be deleted. Configured table analysis rules are uniquely identified by their configured table identifier and analysis rule type.
    ///   - configuredTableIdentifier: The unique identifier for the configured table that the analysis rule applies to. Currently accepts the configured table ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteConfiguredTableAnalysisRule(
        analysisRuleType: ConfiguredTableAnalysisRuleType,
        configuredTableIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteConfiguredTableAnalysisRuleOutput {
        let input = DeleteConfiguredTableAnalysisRuleInput(
            analysisRuleType: analysisRuleType, 
            configuredTableIdentifier: configuredTableIdentifier
        )
        return try await self.deleteConfiguredTableAnalysisRule(input, logger: logger)
    }

    /// Deletes a configured table association.
    @Sendable
    @inlinable
    public func deleteConfiguredTableAssociation(_ input: DeleteConfiguredTableAssociationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteConfiguredTableAssociationOutput {
        try await self.client.execute(
            operation: "DeleteConfiguredTableAssociation", 
            path: "/memberships/{membershipIdentifier}/configuredTableAssociations/{configuredTableAssociationIdentifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a configured table association.
    ///
    /// Parameters:
    ///   - configuredTableAssociationIdentifier: The unique ID for the configured table association to be deleted. Currently accepts the configured table ID.
    ///   - membershipIdentifier: A unique identifier for the membership that the configured table association belongs to. Currently accepts the membership ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteConfiguredTableAssociation(
        configuredTableAssociationIdentifier: String,
        membershipIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteConfiguredTableAssociationOutput {
        let input = DeleteConfiguredTableAssociationInput(
            configuredTableAssociationIdentifier: configuredTableAssociationIdentifier, 
            membershipIdentifier: membershipIdentifier
        )
        return try await self.deleteConfiguredTableAssociation(input, logger: logger)
    }

    /// Deletes an analysis rule for a configured table association.
    @Sendable
    @inlinable
    public func deleteConfiguredTableAssociationAnalysisRule(_ input: DeleteConfiguredTableAssociationAnalysisRuleInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteConfiguredTableAssociationAnalysisRuleOutput {
        try await self.client.execute(
            operation: "DeleteConfiguredTableAssociationAnalysisRule", 
            path: "/memberships/{membershipIdentifier}/configuredTableAssociations/{configuredTableAssociationIdentifier}/analysisRule/{analysisRuleType}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an analysis rule for a configured table association.
    ///
    /// Parameters:
    ///   - analysisRuleType: The type of the analysis rule that you want to delete.
    ///   - configuredTableAssociationIdentifier: The identiﬁer for the conﬁgured table association that's related to the analysis rule that you want to delete.
    ///   - membershipIdentifier:  A unique identifier for the membership that the configured table association belongs to. Currently accepts the membership ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteConfiguredTableAssociationAnalysisRule(
        analysisRuleType: ConfiguredTableAssociationAnalysisRuleType,
        configuredTableAssociationIdentifier: String,
        membershipIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteConfiguredTableAssociationAnalysisRuleOutput {
        let input = DeleteConfiguredTableAssociationAnalysisRuleInput(
            analysisRuleType: analysisRuleType, 
            configuredTableAssociationIdentifier: configuredTableAssociationIdentifier, 
            membershipIdentifier: membershipIdentifier
        )
        return try await self.deleteConfiguredTableAssociationAnalysisRule(input, logger: logger)
    }

    /// Deletes an ID mapping table.
    @Sendable
    @inlinable
    public func deleteIdMappingTable(_ input: DeleteIdMappingTableInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteIdMappingTableOutput {
        try await self.client.execute(
            operation: "DeleteIdMappingTable", 
            path: "/memberships/{membershipIdentifier}/idmappingtables/{idMappingTableIdentifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an ID mapping table.
    ///
    /// Parameters:
    ///   - idMappingTableIdentifier: The unique identifier of the ID mapping table that you want to delete.
    ///   - membershipIdentifier: The unique identifier of the membership that contains the ID mapping table that you want to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteIdMappingTable(
        idMappingTableIdentifier: String,
        membershipIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteIdMappingTableOutput {
        let input = DeleteIdMappingTableInput(
            idMappingTableIdentifier: idMappingTableIdentifier, 
            membershipIdentifier: membershipIdentifier
        )
        return try await self.deleteIdMappingTable(input, logger: logger)
    }

    /// Deletes an ID namespace association.
    @Sendable
    @inlinable
    public func deleteIdNamespaceAssociation(_ input: DeleteIdNamespaceAssociationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteIdNamespaceAssociationOutput {
        try await self.client.execute(
            operation: "DeleteIdNamespaceAssociation", 
            path: "/memberships/{membershipIdentifier}/idnamespaceassociations/{idNamespaceAssociationIdentifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an ID namespace association.
    ///
    /// Parameters:
    ///   - idNamespaceAssociationIdentifier: The unique identifier of the ID namespace association that you want to delete.
    ///   - membershipIdentifier: The unique identifier of the membership that contains the ID namespace association that you want to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteIdNamespaceAssociation(
        idNamespaceAssociationIdentifier: String,
        membershipIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteIdNamespaceAssociationOutput {
        let input = DeleteIdNamespaceAssociationInput(
            idNamespaceAssociationIdentifier: idNamespaceAssociationIdentifier, 
            membershipIdentifier: membershipIdentifier
        )
        return try await self.deleteIdNamespaceAssociation(input, logger: logger)
    }

    /// Removes the specified member from a collaboration. The removed member is placed in the Removed status and can't interact with the collaboration. The removed member's data is inaccessible to active members of the collaboration.
    @Sendable
    @inlinable
    public func deleteMember(_ input: DeleteMemberInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteMemberOutput {
        try await self.client.execute(
            operation: "DeleteMember", 
            path: "/collaborations/{collaborationIdentifier}/member/{accountId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes the specified member from a collaboration. The removed member is placed in the Removed status and can't interact with the collaboration. The removed member's data is inaccessible to active members of the collaboration.
    ///
    /// Parameters:
    ///   - accountId: The account ID of the member to remove.
    ///   - collaborationIdentifier: The unique identifier for the associated collaboration.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteMember(
        accountId: String,
        collaborationIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteMemberOutput {
        let input = DeleteMemberInput(
            accountId: accountId, 
            collaborationIdentifier: collaborationIdentifier
        )
        return try await self.deleteMember(input, logger: logger)
    }

    /// Deletes a specified membership. All resources under a membership must be deleted.
    @Sendable
    @inlinable
    public func deleteMembership(_ input: DeleteMembershipInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteMembershipOutput {
        try await self.client.execute(
            operation: "DeleteMembership", 
            path: "/memberships/{membershipIdentifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a specified membership. All resources under a membership must be deleted.
    ///
    /// Parameters:
    ///   - membershipIdentifier: The identifier for a membership resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteMembership(
        membershipIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteMembershipOutput {
        let input = DeleteMembershipInput(
            membershipIdentifier: membershipIdentifier
        )
        return try await self.deleteMembership(input, logger: logger)
    }

    /// Deletes a privacy budget template for a specified membership.
    @Sendable
    @inlinable
    public func deletePrivacyBudgetTemplate(_ input: DeletePrivacyBudgetTemplateInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeletePrivacyBudgetTemplateOutput {
        try await self.client.execute(
            operation: "DeletePrivacyBudgetTemplate", 
            path: "/memberships/{membershipIdentifier}/privacybudgettemplates/{privacyBudgetTemplateIdentifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a privacy budget template for a specified membership.
    ///
    /// Parameters:
    ///   - membershipIdentifier: A unique identifier for one of your memberships for a collaboration. The privacy budget template is deleted from the collaboration that this membership belongs to. Accepts a membership ID.
    ///   - privacyBudgetTemplateIdentifier: A unique identifier for your privacy budget template.
    ///   - logger: Logger use during operation
    @inlinable
    public func deletePrivacyBudgetTemplate(
        membershipIdentifier: String,
        privacyBudgetTemplateIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeletePrivacyBudgetTemplateOutput {
        let input = DeletePrivacyBudgetTemplateInput(
            membershipIdentifier: membershipIdentifier, 
            privacyBudgetTemplateIdentifier: privacyBudgetTemplateIdentifier
        )
        return try await self.deletePrivacyBudgetTemplate(input, logger: logger)
    }

    /// Retrieves an analysis template.
    @Sendable
    @inlinable
    public func getAnalysisTemplate(_ input: GetAnalysisTemplateInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAnalysisTemplateOutput {
        try await self.client.execute(
            operation: "GetAnalysisTemplate", 
            path: "/memberships/{membershipIdentifier}/analysistemplates/{analysisTemplateIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves an analysis template.
    ///
    /// Parameters:
    ///   - analysisTemplateIdentifier: The identifier for the analysis template resource.
    ///   - membershipIdentifier: The identifier for a membership resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAnalysisTemplate(
        analysisTemplateIdentifier: String,
        membershipIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAnalysisTemplateOutput {
        let input = GetAnalysisTemplateInput(
            analysisTemplateIdentifier: analysisTemplateIdentifier, 
            membershipIdentifier: membershipIdentifier
        )
        return try await self.getAnalysisTemplate(input, logger: logger)
    }

    /// Returns metadata about a collaboration.
    @Sendable
    @inlinable
    public func getCollaboration(_ input: GetCollaborationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCollaborationOutput {
        try await self.client.execute(
            operation: "GetCollaboration", 
            path: "/collaborations/{collaborationIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns metadata about a collaboration.
    ///
    /// Parameters:
    ///   - collaborationIdentifier: The identifier for the collaboration.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCollaboration(
        collaborationIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCollaborationOutput {
        let input = GetCollaborationInput(
            collaborationIdentifier: collaborationIdentifier
        )
        return try await self.getCollaboration(input, logger: logger)
    }

    /// Retrieves an analysis template within a collaboration.
    @Sendable
    @inlinable
    public func getCollaborationAnalysisTemplate(_ input: GetCollaborationAnalysisTemplateInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCollaborationAnalysisTemplateOutput {
        try await self.client.execute(
            operation: "GetCollaborationAnalysisTemplate", 
            path: "/collaborations/{collaborationIdentifier}/analysistemplates/{analysisTemplateArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves an analysis template within a collaboration.
    ///
    /// Parameters:
    ///   - analysisTemplateArn: The Amazon Resource Name (ARN) associated with the analysis template within a collaboration.
    ///   - collaborationIdentifier: A unique identifier for the collaboration that the analysis templates belong to. Currently accepts collaboration ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCollaborationAnalysisTemplate(
        analysisTemplateArn: String,
        collaborationIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCollaborationAnalysisTemplateOutput {
        let input = GetCollaborationAnalysisTemplateInput(
            analysisTemplateArn: analysisTemplateArn, 
            collaborationIdentifier: collaborationIdentifier
        )
        return try await self.getCollaborationAnalysisTemplate(input, logger: logger)
    }

    /// Retrieves a configured audience model association within a collaboration.
    @Sendable
    @inlinable
    public func getCollaborationConfiguredAudienceModelAssociation(_ input: GetCollaborationConfiguredAudienceModelAssociationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCollaborationConfiguredAudienceModelAssociationOutput {
        try await self.client.execute(
            operation: "GetCollaborationConfiguredAudienceModelAssociation", 
            path: "/collaborations/{collaborationIdentifier}/configuredaudiencemodelassociations/{configuredAudienceModelAssociationIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a configured audience model association within a collaboration.
    ///
    /// Parameters:
    ///   - collaborationIdentifier: A unique identifier for the collaboration that the configured audience model association belongs to. Accepts a collaboration ID.
    ///   - configuredAudienceModelAssociationIdentifier: A unique identifier for the configured audience model association that you want to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCollaborationConfiguredAudienceModelAssociation(
        collaborationIdentifier: String,
        configuredAudienceModelAssociationIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCollaborationConfiguredAudienceModelAssociationOutput {
        let input = GetCollaborationConfiguredAudienceModelAssociationInput(
            collaborationIdentifier: collaborationIdentifier, 
            configuredAudienceModelAssociationIdentifier: configuredAudienceModelAssociationIdentifier
        )
        return try await self.getCollaborationConfiguredAudienceModelAssociation(input, logger: logger)
    }

    /// Retrieves an ID namespace association from a specific collaboration.
    @Sendable
    @inlinable
    public func getCollaborationIdNamespaceAssociation(_ input: GetCollaborationIdNamespaceAssociationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCollaborationIdNamespaceAssociationOutput {
        try await self.client.execute(
            operation: "GetCollaborationIdNamespaceAssociation", 
            path: "/collaborations/{collaborationIdentifier}/idnamespaceassociations/{idNamespaceAssociationIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves an ID namespace association from a specific collaboration.
    ///
    /// Parameters:
    ///   - collaborationIdentifier: The unique identifier of the collaboration that contains the ID namespace association that you want to retrieve.
    ///   - idNamespaceAssociationIdentifier: The unique identifier of the ID namespace association that you want to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCollaborationIdNamespaceAssociation(
        collaborationIdentifier: String,
        idNamespaceAssociationIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCollaborationIdNamespaceAssociationOutput {
        let input = GetCollaborationIdNamespaceAssociationInput(
            collaborationIdentifier: collaborationIdentifier, 
            idNamespaceAssociationIdentifier: idNamespaceAssociationIdentifier
        )
        return try await self.getCollaborationIdNamespaceAssociation(input, logger: logger)
    }

    /// Returns details about a specified privacy budget template.
    @Sendable
    @inlinable
    public func getCollaborationPrivacyBudgetTemplate(_ input: GetCollaborationPrivacyBudgetTemplateInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCollaborationPrivacyBudgetTemplateOutput {
        try await self.client.execute(
            operation: "GetCollaborationPrivacyBudgetTemplate", 
            path: "/collaborations/{collaborationIdentifier}/privacybudgettemplates/{privacyBudgetTemplateIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns details about a specified privacy budget template.
    ///
    /// Parameters:
    ///   - collaborationIdentifier: A unique identifier for one of your collaborations.
    ///   - privacyBudgetTemplateIdentifier: A unique identifier for one of your privacy budget templates.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCollaborationPrivacyBudgetTemplate(
        collaborationIdentifier: String,
        privacyBudgetTemplateIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCollaborationPrivacyBudgetTemplateOutput {
        let input = GetCollaborationPrivacyBudgetTemplateInput(
            collaborationIdentifier: collaborationIdentifier, 
            privacyBudgetTemplateIdentifier: privacyBudgetTemplateIdentifier
        )
        return try await self.getCollaborationPrivacyBudgetTemplate(input, logger: logger)
    }

    /// Returns information about a configured audience model association.
    @Sendable
    @inlinable
    public func getConfiguredAudienceModelAssociation(_ input: GetConfiguredAudienceModelAssociationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetConfiguredAudienceModelAssociationOutput {
        try await self.client.execute(
            operation: "GetConfiguredAudienceModelAssociation", 
            path: "/memberships/{membershipIdentifier}/configuredaudiencemodelassociations/{configuredAudienceModelAssociationIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a configured audience model association.
    ///
    /// Parameters:
    ///   - configuredAudienceModelAssociationIdentifier: A unique identifier for the configured audience model association that you want to retrieve.
    ///   - membershipIdentifier: A unique identifier for the membership that contains the configured audience model association that you want to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getConfiguredAudienceModelAssociation(
        configuredAudienceModelAssociationIdentifier: String,
        membershipIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetConfiguredAudienceModelAssociationOutput {
        let input = GetConfiguredAudienceModelAssociationInput(
            configuredAudienceModelAssociationIdentifier: configuredAudienceModelAssociationIdentifier, 
            membershipIdentifier: membershipIdentifier
        )
        return try await self.getConfiguredAudienceModelAssociation(input, logger: logger)
    }

    /// Retrieves a configured table.
    @Sendable
    @inlinable
    public func getConfiguredTable(_ input: GetConfiguredTableInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetConfiguredTableOutput {
        try await self.client.execute(
            operation: "GetConfiguredTable", 
            path: "/configuredTables/{configuredTableIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a configured table.
    ///
    /// Parameters:
    ///   - configuredTableIdentifier: The unique ID for the configured table to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getConfiguredTable(
        configuredTableIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetConfiguredTableOutput {
        let input = GetConfiguredTableInput(
            configuredTableIdentifier: configuredTableIdentifier
        )
        return try await self.getConfiguredTable(input, logger: logger)
    }

    /// Retrieves a configured table analysis rule.
    @Sendable
    @inlinable
    public func getConfiguredTableAnalysisRule(_ input: GetConfiguredTableAnalysisRuleInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetConfiguredTableAnalysisRuleOutput {
        try await self.client.execute(
            operation: "GetConfiguredTableAnalysisRule", 
            path: "/configuredTables/{configuredTableIdentifier}/analysisRule/{analysisRuleType}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a configured table analysis rule.
    ///
    /// Parameters:
    ///   - analysisRuleType: The analysis rule to be retrieved. Configured table analysis rules are uniquely identified by their configured table identifier and analysis rule type.
    ///   - configuredTableIdentifier: The unique identifier for the configured table to retrieve. Currently accepts the configured table ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getConfiguredTableAnalysisRule(
        analysisRuleType: ConfiguredTableAnalysisRuleType,
        configuredTableIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetConfiguredTableAnalysisRuleOutput {
        let input = GetConfiguredTableAnalysisRuleInput(
            analysisRuleType: analysisRuleType, 
            configuredTableIdentifier: configuredTableIdentifier
        )
        return try await self.getConfiguredTableAnalysisRule(input, logger: logger)
    }

    /// Retrieves a configured table association.
    @Sendable
    @inlinable
    public func getConfiguredTableAssociation(_ input: GetConfiguredTableAssociationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetConfiguredTableAssociationOutput {
        try await self.client.execute(
            operation: "GetConfiguredTableAssociation", 
            path: "/memberships/{membershipIdentifier}/configuredTableAssociations/{configuredTableAssociationIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a configured table association.
    ///
    /// Parameters:
    ///   - configuredTableAssociationIdentifier: The unique ID for the configured table association to retrieve. Currently accepts the configured table ID.
    ///   - membershipIdentifier: A unique identifier for the membership that the configured table association belongs to. Currently accepts the membership ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getConfiguredTableAssociation(
        configuredTableAssociationIdentifier: String,
        membershipIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetConfiguredTableAssociationOutput {
        let input = GetConfiguredTableAssociationInput(
            configuredTableAssociationIdentifier: configuredTableAssociationIdentifier, 
            membershipIdentifier: membershipIdentifier
        )
        return try await self.getConfiguredTableAssociation(input, logger: logger)
    }

    ///  Retrieves the analysis rule for a configured table association.
    @Sendable
    @inlinable
    public func getConfiguredTableAssociationAnalysisRule(_ input: GetConfiguredTableAssociationAnalysisRuleInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetConfiguredTableAssociationAnalysisRuleOutput {
        try await self.client.execute(
            operation: "GetConfiguredTableAssociationAnalysisRule", 
            path: "/memberships/{membershipIdentifier}/configuredTableAssociations/{configuredTableAssociationIdentifier}/analysisRule/{analysisRuleType}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Retrieves the analysis rule for a configured table association.
    ///
    /// Parameters:
    ///   - analysisRuleType:  The type of analysis rule that you want to retrieve.
    ///   - configuredTableAssociationIdentifier:  The identiﬁer for the conﬁgured table association that's related to the analysis rule.
    ///   - membershipIdentifier:  A unique identifier for the membership that the configured table association belongs to. Currently accepts the membership ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getConfiguredTableAssociationAnalysisRule(
        analysisRuleType: ConfiguredTableAssociationAnalysisRuleType,
        configuredTableAssociationIdentifier: String,
        membershipIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetConfiguredTableAssociationAnalysisRuleOutput {
        let input = GetConfiguredTableAssociationAnalysisRuleInput(
            analysisRuleType: analysisRuleType, 
            configuredTableAssociationIdentifier: configuredTableAssociationIdentifier, 
            membershipIdentifier: membershipIdentifier
        )
        return try await self.getConfiguredTableAssociationAnalysisRule(input, logger: logger)
    }

    /// Retrieves an ID mapping table.
    @Sendable
    @inlinable
    public func getIdMappingTable(_ input: GetIdMappingTableInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetIdMappingTableOutput {
        try await self.client.execute(
            operation: "GetIdMappingTable", 
            path: "/memberships/{membershipIdentifier}/idmappingtables/{idMappingTableIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves an ID mapping table.
    ///
    /// Parameters:
    ///   - idMappingTableIdentifier: The unique identifier of the ID mapping table identifier that you want to retrieve.
    ///   - membershipIdentifier: The unique identifier of the membership that contains the ID mapping table that you want to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getIdMappingTable(
        idMappingTableIdentifier: String,
        membershipIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetIdMappingTableOutput {
        let input = GetIdMappingTableInput(
            idMappingTableIdentifier: idMappingTableIdentifier, 
            membershipIdentifier: membershipIdentifier
        )
        return try await self.getIdMappingTable(input, logger: logger)
    }

    /// Retrieves an ID namespace association.
    @Sendable
    @inlinable
    public func getIdNamespaceAssociation(_ input: GetIdNamespaceAssociationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetIdNamespaceAssociationOutput {
        try await self.client.execute(
            operation: "GetIdNamespaceAssociation", 
            path: "/memberships/{membershipIdentifier}/idnamespaceassociations/{idNamespaceAssociationIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves an ID namespace association.
    ///
    /// Parameters:
    ///   - idNamespaceAssociationIdentifier: The unique identifier of the ID namespace association that you want to retrieve.
    ///   - membershipIdentifier: The unique identifier of the membership that contains the ID namespace association that you want to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getIdNamespaceAssociation(
        idNamespaceAssociationIdentifier: String,
        membershipIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetIdNamespaceAssociationOutput {
        let input = GetIdNamespaceAssociationInput(
            idNamespaceAssociationIdentifier: idNamespaceAssociationIdentifier, 
            membershipIdentifier: membershipIdentifier
        )
        return try await self.getIdNamespaceAssociation(input, logger: logger)
    }

    /// Retrieves a specified membership for an identifier.
    @Sendable
    @inlinable
    public func getMembership(_ input: GetMembershipInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMembershipOutput {
        try await self.client.execute(
            operation: "GetMembership", 
            path: "/memberships/{membershipIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a specified membership for an identifier.
    ///
    /// Parameters:
    ///   - membershipIdentifier: The identifier for a membership resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func getMembership(
        membershipIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMembershipOutput {
        let input = GetMembershipInput(
            membershipIdentifier: membershipIdentifier
        )
        return try await self.getMembership(input, logger: logger)
    }

    /// Returns details for a specified privacy budget template.
    @Sendable
    @inlinable
    public func getPrivacyBudgetTemplate(_ input: GetPrivacyBudgetTemplateInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetPrivacyBudgetTemplateOutput {
        try await self.client.execute(
            operation: "GetPrivacyBudgetTemplate", 
            path: "/memberships/{membershipIdentifier}/privacybudgettemplates/{privacyBudgetTemplateIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns details for a specified privacy budget template.
    ///
    /// Parameters:
    ///   - membershipIdentifier: A unique identifier for one of your memberships for a collaboration. The privacy budget template is retrieved from the collaboration that this membership belongs to. Accepts a membership ID.
    ///   - privacyBudgetTemplateIdentifier: A unique identifier for your privacy budget template.
    ///   - logger: Logger use during operation
    @inlinable
    public func getPrivacyBudgetTemplate(
        membershipIdentifier: String,
        privacyBudgetTemplateIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetPrivacyBudgetTemplateOutput {
        let input = GetPrivacyBudgetTemplateInput(
            membershipIdentifier: membershipIdentifier, 
            privacyBudgetTemplateIdentifier: privacyBudgetTemplateIdentifier
        )
        return try await self.getPrivacyBudgetTemplate(input, logger: logger)
    }

    /// Returns job processing metadata.
    @Sendable
    @inlinable
    public func getProtectedJob(_ input: GetProtectedJobInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetProtectedJobOutput {
        try await self.client.execute(
            operation: "GetProtectedJob", 
            path: "/memberships/{membershipIdentifier}/protectedJobs/{protectedJobIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns job processing metadata.
    ///
    /// Parameters:
    ///   - membershipIdentifier:  The identifier for a membership in a protected job instance.
    ///   - protectedJobIdentifier:  The identifier for the protected job instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func getProtectedJob(
        membershipIdentifier: String,
        protectedJobIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetProtectedJobOutput {
        let input = GetProtectedJobInput(
            membershipIdentifier: membershipIdentifier, 
            protectedJobIdentifier: protectedJobIdentifier
        )
        return try await self.getProtectedJob(input, logger: logger)
    }

    /// Returns query processing metadata.
    @Sendable
    @inlinable
    public func getProtectedQuery(_ input: GetProtectedQueryInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetProtectedQueryOutput {
        try await self.client.execute(
            operation: "GetProtectedQuery", 
            path: "/memberships/{membershipIdentifier}/protectedQueries/{protectedQueryIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns query processing metadata.
    ///
    /// Parameters:
    ///   - membershipIdentifier: The identifier for a membership in a protected query instance.
    ///   - protectedQueryIdentifier: The identifier for a protected query instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func getProtectedQuery(
        membershipIdentifier: String,
        protectedQueryIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetProtectedQueryOutput {
        let input = GetProtectedQueryInput(
            membershipIdentifier: membershipIdentifier, 
            protectedQueryIdentifier: protectedQueryIdentifier
        )
        return try await self.getProtectedQuery(input, logger: logger)
    }

    /// Retrieves the schema for a relation within a collaboration.
    @Sendable
    @inlinable
    public func getSchema(_ input: GetSchemaInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSchemaOutput {
        try await self.client.execute(
            operation: "GetSchema", 
            path: "/collaborations/{collaborationIdentifier}/schemas/{name}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the schema for a relation within a collaboration.
    ///
    /// Parameters:
    ///   - collaborationIdentifier: A unique identifier for the collaboration that the schema belongs to. Currently accepts a collaboration ID.
    ///   - name: The name of the relation to retrieve the schema for.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSchema(
        collaborationIdentifier: String,
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSchemaOutput {
        let input = GetSchemaInput(
            collaborationIdentifier: collaborationIdentifier, 
            name: name
        )
        return try await self.getSchema(input, logger: logger)
    }

    /// Retrieves a schema analysis rule.
    @Sendable
    @inlinable
    public func getSchemaAnalysisRule(_ input: GetSchemaAnalysisRuleInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSchemaAnalysisRuleOutput {
        try await self.client.execute(
            operation: "GetSchemaAnalysisRule", 
            path: "/collaborations/{collaborationIdentifier}/schemas/{name}/analysisRule/{type}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a schema analysis rule.
    ///
    /// Parameters:
    ///   - collaborationIdentifier: A unique identifier for the collaboration that the schema belongs to. Currently accepts a collaboration ID.
    ///   - name: The name of the schema to retrieve the analysis rule for.
    ///   - type: The type of the schema analysis rule to retrieve. Schema analysis rules are uniquely identified by a combination of the collaboration, the schema name, and their type.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSchemaAnalysisRule(
        collaborationIdentifier: String,
        name: String,
        type: AnalysisRuleType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSchemaAnalysisRuleOutput {
        let input = GetSchemaAnalysisRuleInput(
            collaborationIdentifier: collaborationIdentifier, 
            name: name, 
            type: type
        )
        return try await self.getSchemaAnalysisRule(input, logger: logger)
    }

    /// Lists analysis templates that the caller owns.
    @Sendable
    @inlinable
    public func listAnalysisTemplates(_ input: ListAnalysisTemplatesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAnalysisTemplatesOutput {
        try await self.client.execute(
            operation: "ListAnalysisTemplates", 
            path: "/memberships/{membershipIdentifier}/analysistemplates", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists analysis templates that the caller owns.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - membershipIdentifier: The identifier for a membership resource.
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAnalysisTemplates(
        maxResults: Int? = nil,
        membershipIdentifier: String,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAnalysisTemplatesOutput {
        let input = ListAnalysisTemplatesInput(
            maxResults: maxResults, 
            membershipIdentifier: membershipIdentifier, 
            nextToken: nextToken
        )
        return try await self.listAnalysisTemplates(input, logger: logger)
    }

    /// Lists analysis templates within a collaboration.
    @Sendable
    @inlinable
    public func listCollaborationAnalysisTemplates(_ input: ListCollaborationAnalysisTemplatesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCollaborationAnalysisTemplatesOutput {
        try await self.client.execute(
            operation: "ListCollaborationAnalysisTemplates", 
            path: "/collaborations/{collaborationIdentifier}/analysistemplates", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists analysis templates within a collaboration.
    ///
    /// Parameters:
    ///   - collaborationIdentifier: A unique identifier for the collaboration that the analysis templates belong to. Currently accepts collaboration ID.
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCollaborationAnalysisTemplates(
        collaborationIdentifier: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCollaborationAnalysisTemplatesOutput {
        let input = ListCollaborationAnalysisTemplatesInput(
            collaborationIdentifier: collaborationIdentifier, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listCollaborationAnalysisTemplates(input, logger: logger)
    }

    /// Lists configured audience model associations within a collaboration.
    @Sendable
    @inlinable
    public func listCollaborationConfiguredAudienceModelAssociations(_ input: ListCollaborationConfiguredAudienceModelAssociationsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCollaborationConfiguredAudienceModelAssociationsOutput {
        try await self.client.execute(
            operation: "ListCollaborationConfiguredAudienceModelAssociations", 
            path: "/collaborations/{collaborationIdentifier}/configuredaudiencemodelassociations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists configured audience model associations within a collaboration.
    ///
    /// Parameters:
    ///   - collaborationIdentifier: A unique identifier for the collaboration that the configured audience model association belongs to. Accepts a collaboration ID.
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCollaborationConfiguredAudienceModelAssociations(
        collaborationIdentifier: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCollaborationConfiguredAudienceModelAssociationsOutput {
        let input = ListCollaborationConfiguredAudienceModelAssociationsInput(
            collaborationIdentifier: collaborationIdentifier, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listCollaborationConfiguredAudienceModelAssociations(input, logger: logger)
    }

    /// Returns a list of the ID namespace associations in a collaboration.
    @Sendable
    @inlinable
    public func listCollaborationIdNamespaceAssociations(_ input: ListCollaborationIdNamespaceAssociationsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCollaborationIdNamespaceAssociationsOutput {
        try await self.client.execute(
            operation: "ListCollaborationIdNamespaceAssociations", 
            path: "/collaborations/{collaborationIdentifier}/idnamespaceassociations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of the ID namespace associations in a collaboration.
    ///
    /// Parameters:
    ///   - collaborationIdentifier: The unique identifier of the collaboration that contains the ID namespace associations that you want to retrieve.
    ///   - maxResults: The maximum size of the results that is returned per call. Service chooses a default if it has not been set. Service may return a nextToken even if the maximum results has not been met.&gt;
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCollaborationIdNamespaceAssociations(
        collaborationIdentifier: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCollaborationIdNamespaceAssociationsOutput {
        let input = ListCollaborationIdNamespaceAssociationsInput(
            collaborationIdentifier: collaborationIdentifier, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listCollaborationIdNamespaceAssociations(input, logger: logger)
    }

    /// Returns an array that summarizes each privacy budget template in a specified collaboration.
    @Sendable
    @inlinable
    public func listCollaborationPrivacyBudgetTemplates(_ input: ListCollaborationPrivacyBudgetTemplatesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCollaborationPrivacyBudgetTemplatesOutput {
        try await self.client.execute(
            operation: "ListCollaborationPrivacyBudgetTemplates", 
            path: "/collaborations/{collaborationIdentifier}/privacybudgettemplates", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns an array that summarizes each privacy budget template in a specified collaboration.
    ///
    /// Parameters:
    ///   - collaborationIdentifier: A unique identifier for one of your collaborations.
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCollaborationPrivacyBudgetTemplates(
        collaborationIdentifier: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCollaborationPrivacyBudgetTemplatesOutput {
        let input = ListCollaborationPrivacyBudgetTemplatesInput(
            collaborationIdentifier: collaborationIdentifier, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listCollaborationPrivacyBudgetTemplates(input, logger: logger)
    }

    /// Returns an array that summarizes each privacy budget in a specified collaboration. The summary includes the collaboration ARN, creation time, creating account, and privacy budget details.
    @Sendable
    @inlinable
    public func listCollaborationPrivacyBudgets(_ input: ListCollaborationPrivacyBudgetsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCollaborationPrivacyBudgetsOutput {
        try await self.client.execute(
            operation: "ListCollaborationPrivacyBudgets", 
            path: "/collaborations/{collaborationIdentifier}/privacybudgets", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns an array that summarizes each privacy budget in a specified collaboration. The summary includes the collaboration ARN, creation time, creating account, and privacy budget details.
    ///
    /// Parameters:
    ///   - collaborationIdentifier: A unique identifier for one of your collaborations.
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - privacyBudgetType: Specifies the type of the privacy budget.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCollaborationPrivacyBudgets(
        collaborationIdentifier: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        privacyBudgetType: PrivacyBudgetType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCollaborationPrivacyBudgetsOutput {
        let input = ListCollaborationPrivacyBudgetsInput(
            collaborationIdentifier: collaborationIdentifier, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            privacyBudgetType: privacyBudgetType
        )
        return try await self.listCollaborationPrivacyBudgets(input, logger: logger)
    }

    /// Lists collaborations the caller owns, is active in, or has been invited to.
    @Sendable
    @inlinable
    public func listCollaborations(_ input: ListCollaborationsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCollaborationsOutput {
        try await self.client.execute(
            operation: "ListCollaborations", 
            path: "/collaborations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists collaborations the caller owns, is active in, or has been invited to.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - memberStatus: The caller's status in a collaboration.
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCollaborations(
        maxResults: Int? = nil,
        memberStatus: FilterableMemberStatus? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCollaborationsOutput {
        let input = ListCollaborationsInput(
            maxResults: maxResults, 
            memberStatus: memberStatus, 
            nextToken: nextToken
        )
        return try await self.listCollaborations(input, logger: logger)
    }

    /// Lists information about requested configured audience model associations.
    @Sendable
    @inlinable
    public func listConfiguredAudienceModelAssociations(_ input: ListConfiguredAudienceModelAssociationsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListConfiguredAudienceModelAssociationsOutput {
        try await self.client.execute(
            operation: "ListConfiguredAudienceModelAssociations", 
            path: "/memberships/{membershipIdentifier}/configuredaudiencemodelassociations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists information about requested configured audience model associations.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - membershipIdentifier: A unique identifier for a membership that contains the configured audience model associations that you want to retrieve.
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listConfiguredAudienceModelAssociations(
        maxResults: Int? = nil,
        membershipIdentifier: String,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListConfiguredAudienceModelAssociationsOutput {
        let input = ListConfiguredAudienceModelAssociationsInput(
            maxResults: maxResults, 
            membershipIdentifier: membershipIdentifier, 
            nextToken: nextToken
        )
        return try await self.listConfiguredAudienceModelAssociations(input, logger: logger)
    }

    /// Lists configured table associations for a membership.
    @Sendable
    @inlinable
    public func listConfiguredTableAssociations(_ input: ListConfiguredTableAssociationsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListConfiguredTableAssociationsOutput {
        try await self.client.execute(
            operation: "ListConfiguredTableAssociations", 
            path: "/memberships/{membershipIdentifier}/configuredTableAssociations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists configured table associations for a membership.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - membershipIdentifier: A unique identifier for the membership to list configured table associations for. Currently accepts the membership ID.
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listConfiguredTableAssociations(
        maxResults: Int? = nil,
        membershipIdentifier: String,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListConfiguredTableAssociationsOutput {
        let input = ListConfiguredTableAssociationsInput(
            maxResults: maxResults, 
            membershipIdentifier: membershipIdentifier, 
            nextToken: nextToken
        )
        return try await self.listConfiguredTableAssociations(input, logger: logger)
    }

    /// Lists configured tables.
    @Sendable
    @inlinable
    public func listConfiguredTables(_ input: ListConfiguredTablesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListConfiguredTablesOutput {
        try await self.client.execute(
            operation: "ListConfiguredTables", 
            path: "/configuredTables", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists configured tables.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listConfiguredTables(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListConfiguredTablesOutput {
        let input = ListConfiguredTablesInput(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listConfiguredTables(input, logger: logger)
    }

    /// Returns a list of ID mapping tables.
    @Sendable
    @inlinable
    public func listIdMappingTables(_ input: ListIdMappingTablesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListIdMappingTablesOutput {
        try await self.client.execute(
            operation: "ListIdMappingTables", 
            path: "/memberships/{membershipIdentifier}/idmappingtables", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of ID mapping tables.
    ///
    /// Parameters:
    ///   - maxResults: The maximum size of the results that is returned per call. Service chooses a default if it has not been set. Service may return a nextToken even if the maximum results has not been met.
    ///   - membershipIdentifier: The unique identifier of the membership that contains the ID mapping tables that you want to view.
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listIdMappingTables(
        maxResults: Int? = nil,
        membershipIdentifier: String,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListIdMappingTablesOutput {
        let input = ListIdMappingTablesInput(
            maxResults: maxResults, 
            membershipIdentifier: membershipIdentifier, 
            nextToken: nextToken
        )
        return try await self.listIdMappingTables(input, logger: logger)
    }

    /// Returns a list of ID namespace associations.
    @Sendable
    @inlinable
    public func listIdNamespaceAssociations(_ input: ListIdNamespaceAssociationsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListIdNamespaceAssociationsOutput {
        try await self.client.execute(
            operation: "ListIdNamespaceAssociations", 
            path: "/memberships/{membershipIdentifier}/idnamespaceassociations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of ID namespace associations.
    ///
    /// Parameters:
    ///   - maxResults: The maximum size of the results that is returned per call. Service chooses a default if it has not been set. Service may return a nextToken even if the maximum results has not been met.
    ///   - membershipIdentifier: The unique identifier of the membership that contains the ID namespace association that you want to view.
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listIdNamespaceAssociations(
        maxResults: Int? = nil,
        membershipIdentifier: String,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListIdNamespaceAssociationsOutput {
        let input = ListIdNamespaceAssociationsInput(
            maxResults: maxResults, 
            membershipIdentifier: membershipIdentifier, 
            nextToken: nextToken
        )
        return try await self.listIdNamespaceAssociations(input, logger: logger)
    }

    /// Lists all members within a collaboration.
    @Sendable
    @inlinable
    public func listMembers(_ input: ListMembersInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListMembersOutput {
        try await self.client.execute(
            operation: "ListMembers", 
            path: "/collaborations/{collaborationIdentifier}/members", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all members within a collaboration.
    ///
    /// Parameters:
    ///   - collaborationIdentifier: The identifier of the collaboration in which the members are listed.
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listMembers(
        collaborationIdentifier: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListMembersOutput {
        let input = ListMembersInput(
            collaborationIdentifier: collaborationIdentifier, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listMembers(input, logger: logger)
    }

    /// Lists all memberships resources within the caller's account.
    @Sendable
    @inlinable
    public func listMemberships(_ input: ListMembershipsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListMembershipsOutput {
        try await self.client.execute(
            operation: "ListMemberships", 
            path: "/memberships", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all memberships resources within the caller's account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - status: A filter which will return only memberships in the specified status.
    ///   - logger: Logger use during operation
    @inlinable
    public func listMemberships(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        status: MembershipStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListMembershipsOutput {
        let input = ListMembershipsInput(
            maxResults: maxResults, 
            nextToken: nextToken, 
            status: status
        )
        return try await self.listMemberships(input, logger: logger)
    }

    /// Returns detailed information about the privacy budget templates in a specified membership.
    @Sendable
    @inlinable
    public func listPrivacyBudgetTemplates(_ input: ListPrivacyBudgetTemplatesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListPrivacyBudgetTemplatesOutput {
        try await self.client.execute(
            operation: "ListPrivacyBudgetTemplates", 
            path: "/memberships/{membershipIdentifier}/privacybudgettemplates", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns detailed information about the privacy budget templates in a specified membership.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - membershipIdentifier: A unique identifier for one of your memberships for a collaboration. The privacy budget templates are retrieved from the collaboration that this membership belongs to. Accepts a membership ID.
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listPrivacyBudgetTemplates(
        maxResults: Int? = nil,
        membershipIdentifier: String,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListPrivacyBudgetTemplatesOutput {
        let input = ListPrivacyBudgetTemplatesInput(
            maxResults: maxResults, 
            membershipIdentifier: membershipIdentifier, 
            nextToken: nextToken
        )
        return try await self.listPrivacyBudgetTemplates(input, logger: logger)
    }

    /// Returns detailed information about the privacy budgets in a specified membership.
    @Sendable
    @inlinable
    public func listPrivacyBudgets(_ input: ListPrivacyBudgetsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListPrivacyBudgetsOutput {
        try await self.client.execute(
            operation: "ListPrivacyBudgets", 
            path: "/memberships/{membershipIdentifier}/privacybudgets", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns detailed information about the privacy budgets in a specified membership.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - membershipIdentifier: A unique identifier for one of your memberships for a collaboration. The privacy budget is retrieved from the collaboration that this membership belongs to. Accepts a membership ID.
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - privacyBudgetType: The privacy budget type.
    ///   - logger: Logger use during operation
    @inlinable
    public func listPrivacyBudgets(
        maxResults: Int? = nil,
        membershipIdentifier: String,
        nextToken: String? = nil,
        privacyBudgetType: PrivacyBudgetType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListPrivacyBudgetsOutput {
        let input = ListPrivacyBudgetsInput(
            maxResults: maxResults, 
            membershipIdentifier: membershipIdentifier, 
            nextToken: nextToken, 
            privacyBudgetType: privacyBudgetType
        )
        return try await self.listPrivacyBudgets(input, logger: logger)
    }

    /// Lists protected jobs, sorted by most recent job.
    @Sendable
    @inlinable
    public func listProtectedJobs(_ input: ListProtectedJobsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListProtectedJobsOutput {
        try await self.client.execute(
            operation: "ListProtectedJobs", 
            path: "/memberships/{membershipIdentifier}/protectedJobs", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists protected jobs, sorted by most recent job.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - membershipIdentifier: The identifier for the membership in the collaboration.
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - status: A filter on the status of the protected job.
    ///   - logger: Logger use during operation
    @inlinable
    public func listProtectedJobs(
        maxResults: Int? = nil,
        membershipIdentifier: String,
        nextToken: String? = nil,
        status: ProtectedJobStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListProtectedJobsOutput {
        let input = ListProtectedJobsInput(
            maxResults: maxResults, 
            membershipIdentifier: membershipIdentifier, 
            nextToken: nextToken, 
            status: status
        )
        return try await self.listProtectedJobs(input, logger: logger)
    }

    /// Lists protected queries, sorted by the most recent query.
    @Sendable
    @inlinable
    public func listProtectedQueries(_ input: ListProtectedQueriesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListProtectedQueriesOutput {
        try await self.client.execute(
            operation: "ListProtectedQueries", 
            path: "/memberships/{membershipIdentifier}/protectedQueries", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists protected queries, sorted by the most recent query.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - membershipIdentifier: The identifier for the membership in the collaboration.
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - status: A filter on the status of the protected query.
    ///   - logger: Logger use during operation
    @inlinable
    public func listProtectedQueries(
        maxResults: Int? = nil,
        membershipIdentifier: String,
        nextToken: String? = nil,
        status: ProtectedQueryStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListProtectedQueriesOutput {
        let input = ListProtectedQueriesInput(
            maxResults: maxResults, 
            membershipIdentifier: membershipIdentifier, 
            nextToken: nextToken, 
            status: status
        )
        return try await self.listProtectedQueries(input, logger: logger)
    }

    /// Lists the schemas for relations within a collaboration.
    @Sendable
    @inlinable
    public func listSchemas(_ input: ListSchemasInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSchemasOutput {
        try await self.client.execute(
            operation: "ListSchemas", 
            path: "/collaborations/{collaborationIdentifier}/schemas", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the schemas for relations within a collaboration.
    ///
    /// Parameters:
    ///   - collaborationIdentifier: A unique identifier for the collaboration that the schema belongs to. Currently accepts a collaboration ID.
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - schemaType: If present, filter schemas by schema type.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSchemas(
        collaborationIdentifier: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        schemaType: SchemaType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSchemasOutput {
        let input = ListSchemasInput(
            collaborationIdentifier: collaborationIdentifier, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            schemaType: schemaType
        )
        return try await self.listSchemas(input, logger: logger)
    }

    /// Lists all of the tags that have been added to a resource.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceOutput {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all of the tags that have been added to a resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) associated with the resource you want to list tags on.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceOutput {
        let input = ListTagsForResourceInput(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Defines the information that's necessary to populate an ID mapping table.
    @Sendable
    @inlinable
    public func populateIdMappingTable(_ input: PopulateIdMappingTableInput, logger: Logger = AWSClient.loggingDisabled) async throws -> PopulateIdMappingTableOutput {
        try await self.client.execute(
            operation: "PopulateIdMappingTable", 
            path: "/memberships/{membershipIdentifier}/idmappingtables/{idMappingTableIdentifier}/populate", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Defines the information that's necessary to populate an ID mapping table.
    ///
    /// Parameters:
    ///   - idMappingTableIdentifier: The unique identifier of the ID mapping table that you want to populate.
    ///   - membershipIdentifier: The unique identifier of the membership that contains the ID mapping table that you want to populate.
    ///   - logger: Logger use during operation
    @inlinable
    public func populateIdMappingTable(
        idMappingTableIdentifier: String,
        membershipIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PopulateIdMappingTableOutput {
        let input = PopulateIdMappingTableInput(
            idMappingTableIdentifier: idMappingTableIdentifier, 
            membershipIdentifier: membershipIdentifier
        )
        return try await self.populateIdMappingTable(input, logger: logger)
    }

    /// An estimate of the number of aggregation functions that the member who can query can run given epsilon and noise parameters.
    @Sendable
    @inlinable
    public func previewPrivacyImpact(_ input: PreviewPrivacyImpactInput, logger: Logger = AWSClient.loggingDisabled) async throws -> PreviewPrivacyImpactOutput {
        try await self.client.execute(
            operation: "PreviewPrivacyImpact", 
            path: "/memberships/{membershipIdentifier}/previewprivacyimpact", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// An estimate of the number of aggregation functions that the member who can query can run given epsilon and noise parameters.
    ///
    /// Parameters:
    ///   - membershipIdentifier: A unique identifier for one of your memberships for a collaboration. Accepts a membership ID.
    ///   - parameters: Specifies the desired epsilon and noise parameters to preview.
    ///   - logger: Logger use during operation
    @inlinable
    public func previewPrivacyImpact(
        membershipIdentifier: String,
        parameters: PreviewPrivacyImpactParametersInput,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PreviewPrivacyImpactOutput {
        let input = PreviewPrivacyImpactInput(
            membershipIdentifier: membershipIdentifier, 
            parameters: parameters
        )
        return try await self.previewPrivacyImpact(input, logger: logger)
    }

    /// Creates a protected job that is started by Clean Rooms.
    @Sendable
    @inlinable
    public func startProtectedJob(_ input: StartProtectedJobInput, logger: Logger = AWSClient.loggingDisabled) async throws -> StartProtectedJobOutput {
        try await self.client.execute(
            operation: "StartProtectedJob", 
            path: "/memberships/{membershipIdentifier}/protectedJobs", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a protected job that is started by Clean Rooms.
    ///
    /// Parameters:
    ///   - jobParameters:  The job parameters.
    ///   - membershipIdentifier: A unique identifier for the membership to run this job against. Currently accepts a membership ID.
    ///   - resultConfiguration: The details needed to write the job results.
    ///   - type:  The type of protected job to start.
    ///   - logger: Logger use during operation
    @inlinable
    public func startProtectedJob(
        jobParameters: ProtectedJobParameters,
        membershipIdentifier: String,
        resultConfiguration: ProtectedJobResultConfigurationInput? = nil,
        type: ProtectedJobType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartProtectedJobOutput {
        let input = StartProtectedJobInput(
            jobParameters: jobParameters, 
            membershipIdentifier: membershipIdentifier, 
            resultConfiguration: resultConfiguration, 
            type: type
        )
        return try await self.startProtectedJob(input, logger: logger)
    }

    /// Creates a protected query that is started by Clean Rooms.
    @Sendable
    @inlinable
    public func startProtectedQuery(_ input: StartProtectedQueryInput, logger: Logger = AWSClient.loggingDisabled) async throws -> StartProtectedQueryOutput {
        try await self.client.execute(
            operation: "StartProtectedQuery", 
            path: "/memberships/{membershipIdentifier}/protectedQueries", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a protected query that is started by Clean Rooms.
    ///
    /// Parameters:
    ///   - computeConfiguration:  The compute configuration for the protected query.
    ///   - membershipIdentifier: A unique identifier for the membership to run this query against. Currently accepts a membership ID.
    ///   - resultConfiguration: The details needed to write the query results.
    ///   - sqlParameters: The protected SQL query parameters.
    ///   - type: The type of the protected query to be started.
    ///   - logger: Logger use during operation
    @inlinable
    public func startProtectedQuery(
        computeConfiguration: ComputeConfiguration? = nil,
        membershipIdentifier: String,
        resultConfiguration: ProtectedQueryResultConfiguration? = nil,
        sqlParameters: ProtectedQuerySQLParameters,
        type: ProtectedQueryType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartProtectedQueryOutput {
        let input = StartProtectedQueryInput(
            computeConfiguration: computeConfiguration, 
            membershipIdentifier: membershipIdentifier, 
            resultConfiguration: resultConfiguration, 
            sqlParameters: sqlParameters, 
            type: type
        )
        return try await self.startProtectedQuery(input, logger: logger)
    }

    /// Tags a resource.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceInput, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceOutput {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Tags a resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) associated with the resource you want to tag.
    ///   - tags: A map of objects specifying each key name and value.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceOutput {
        let input = TagResourceInput(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Removes a tag or list of tags from a resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceOutput {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes a tag or list of tags from a resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) associated with the resource you want to remove the tag from.
    ///   - tagKeys: A list of key names of tags to be removed.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceOutput {
        let input = UntagResourceInput(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates the analysis template metadata.
    @Sendable
    @inlinable
    public func updateAnalysisTemplate(_ input: UpdateAnalysisTemplateInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAnalysisTemplateOutput {
        try await self.client.execute(
            operation: "UpdateAnalysisTemplate", 
            path: "/memberships/{membershipIdentifier}/analysistemplates/{analysisTemplateIdentifier}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the analysis template metadata.
    ///
    /// Parameters:
    ///   - analysisTemplateIdentifier: The identifier for the analysis template resource.
    ///   - description: A new description for the analysis template.
    ///   - membershipIdentifier: The identifier for a membership resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAnalysisTemplate(
        analysisTemplateIdentifier: String,
        description: String? = nil,
        membershipIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAnalysisTemplateOutput {
        let input = UpdateAnalysisTemplateInput(
            analysisTemplateIdentifier: analysisTemplateIdentifier, 
            description: description, 
            membershipIdentifier: membershipIdentifier
        )
        return try await self.updateAnalysisTemplate(input, logger: logger)
    }

    /// Updates collaboration metadata and can only be called by the collaboration owner.
    @Sendable
    @inlinable
    public func updateCollaboration(_ input: UpdateCollaborationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateCollaborationOutput {
        try await self.client.execute(
            operation: "UpdateCollaboration", 
            path: "/collaborations/{collaborationIdentifier}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates collaboration metadata and can only be called by the collaboration owner.
    ///
    /// Parameters:
    ///   - analyticsEngine: The analytics engine.
    ///   - collaborationIdentifier: The identifier for the collaboration.
    ///   - description: A description of the collaboration.
    ///   - name: A human-readable identifier provided by the collaboration owner. Display names are not unique.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateCollaboration(
        analyticsEngine: AnalyticsEngine? = nil,
        collaborationIdentifier: String,
        description: String? = nil,
        name: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateCollaborationOutput {
        let input = UpdateCollaborationInput(
            analyticsEngine: analyticsEngine, 
            collaborationIdentifier: collaborationIdentifier, 
            description: description, 
            name: name
        )
        return try await self.updateCollaboration(input, logger: logger)
    }

    /// Provides the details necessary to update a configured audience model association.
    @Sendable
    @inlinable
    public func updateConfiguredAudienceModelAssociation(_ input: UpdateConfiguredAudienceModelAssociationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateConfiguredAudienceModelAssociationOutput {
        try await self.client.execute(
            operation: "UpdateConfiguredAudienceModelAssociation", 
            path: "/memberships/{membershipIdentifier}/configuredaudiencemodelassociations/{configuredAudienceModelAssociationIdentifier}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides the details necessary to update a configured audience model association.
    ///
    /// Parameters:
    ///   - configuredAudienceModelAssociationIdentifier: A unique identifier for the configured audience model association that you want to update.
    ///   - description: A new description for the configured audience model association.
    ///   - membershipIdentifier: A unique identifier of the membership that contains the configured audience model association that you want to update.
    ///   - name: A new name for the configured audience model association.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateConfiguredAudienceModelAssociation(
        configuredAudienceModelAssociationIdentifier: String,
        description: String? = nil,
        membershipIdentifier: String,
        name: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateConfiguredAudienceModelAssociationOutput {
        let input = UpdateConfiguredAudienceModelAssociationInput(
            configuredAudienceModelAssociationIdentifier: configuredAudienceModelAssociationIdentifier, 
            description: description, 
            membershipIdentifier: membershipIdentifier, 
            name: name
        )
        return try await self.updateConfiguredAudienceModelAssociation(input, logger: logger)
    }

    /// Updates a configured table.
    @Sendable
    @inlinable
    public func updateConfiguredTable(_ input: UpdateConfiguredTableInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateConfiguredTableOutput {
        try await self.client.execute(
            operation: "UpdateConfiguredTable", 
            path: "/configuredTables/{configuredTableIdentifier}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a configured table.
    ///
    /// Parameters:
    ///   - analysisMethod:  The analysis method for the configured table.  DIRECT_QUERY allows SQL queries to be run directly on this table.  DIRECT_JOB allows PySpark jobs to be run directly on this table.  MULTIPLE allows both SQL queries and PySpark jobs to be run directly on this table.
    ///   - configuredTableIdentifier: The identifier for the configured table to update. Currently accepts the configured table ID.
    ///   - description: A new description for the configured table.
    ///   - name: A new name for the configured table.
    ///   - selectedAnalysisMethods:  The selected analysis methods for the table configuration update.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateConfiguredTable(
        analysisMethod: AnalysisMethod? = nil,
        configuredTableIdentifier: String,
        description: String? = nil,
        name: String? = nil,
        selectedAnalysisMethods: [SelectedAnalysisMethod]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateConfiguredTableOutput {
        let input = UpdateConfiguredTableInput(
            analysisMethod: analysisMethod, 
            configuredTableIdentifier: configuredTableIdentifier, 
            description: description, 
            name: name, 
            selectedAnalysisMethods: selectedAnalysisMethods
        )
        return try await self.updateConfiguredTable(input, logger: logger)
    }

    /// Updates a configured table analysis rule.
    @Sendable
    @inlinable
    public func updateConfiguredTableAnalysisRule(_ input: UpdateConfiguredTableAnalysisRuleInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateConfiguredTableAnalysisRuleOutput {
        try await self.client.execute(
            operation: "UpdateConfiguredTableAnalysisRule", 
            path: "/configuredTables/{configuredTableIdentifier}/analysisRule/{analysisRuleType}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a configured table analysis rule.
    ///
    /// Parameters:
    ///   - analysisRulePolicy: The new analysis rule policy for the configured table analysis rule.
    ///   - analysisRuleType: The analysis rule type to be updated. Configured table analysis rules are uniquely identified by their configured table identifier and analysis rule type.
    ///   - configuredTableIdentifier: The unique identifier for the configured table that the analysis rule applies to. Currently accepts the configured table ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateConfiguredTableAnalysisRule(
        analysisRulePolicy: ConfiguredTableAnalysisRulePolicy,
        analysisRuleType: ConfiguredTableAnalysisRuleType,
        configuredTableIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateConfiguredTableAnalysisRuleOutput {
        let input = UpdateConfiguredTableAnalysisRuleInput(
            analysisRulePolicy: analysisRulePolicy, 
            analysisRuleType: analysisRuleType, 
            configuredTableIdentifier: configuredTableIdentifier
        )
        return try await self.updateConfiguredTableAnalysisRule(input, logger: logger)
    }

    /// Updates a configured table association.
    @Sendable
    @inlinable
    public func updateConfiguredTableAssociation(_ input: UpdateConfiguredTableAssociationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateConfiguredTableAssociationOutput {
        try await self.client.execute(
            operation: "UpdateConfiguredTableAssociation", 
            path: "/memberships/{membershipIdentifier}/configuredTableAssociations/{configuredTableAssociationIdentifier}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a configured table association.
    ///
    /// Parameters:
    ///   - configuredTableAssociationIdentifier: The unique identifier for the configured table association to update. Currently accepts the configured table association ID.
    ///   - description: A new description for the configured table association.
    ///   - membershipIdentifier: The unique ID for the membership that the configured table association belongs to.
    ///   - roleArn: The service will assume this role to access catalog metadata and query the table.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateConfiguredTableAssociation(
        configuredTableAssociationIdentifier: String,
        description: String? = nil,
        membershipIdentifier: String,
        roleArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateConfiguredTableAssociationOutput {
        let input = UpdateConfiguredTableAssociationInput(
            configuredTableAssociationIdentifier: configuredTableAssociationIdentifier, 
            description: description, 
            membershipIdentifier: membershipIdentifier, 
            roleArn: roleArn
        )
        return try await self.updateConfiguredTableAssociation(input, logger: logger)
    }

    ///  Updates the analysis rule for a configured table association.
    @Sendable
    @inlinable
    public func updateConfiguredTableAssociationAnalysisRule(_ input: UpdateConfiguredTableAssociationAnalysisRuleInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateConfiguredTableAssociationAnalysisRuleOutput {
        try await self.client.execute(
            operation: "UpdateConfiguredTableAssociationAnalysisRule", 
            path: "/memberships/{membershipIdentifier}/configuredTableAssociations/{configuredTableAssociationIdentifier}/analysisRule/{analysisRuleType}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Updates the analysis rule for a configured table association.
    ///
    /// Parameters:
    ///   - analysisRulePolicy:  The updated analysis rule policy for the conﬁgured table association.
    ///   - analysisRuleType:  The analysis rule type that you want to update.
    ///   - configuredTableAssociationIdentifier:  The identifier for the configured table association to update.
    ///   - membershipIdentifier:  A unique identifier for the membership that the configured table association belongs to. Currently accepts the membership ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateConfiguredTableAssociationAnalysisRule(
        analysisRulePolicy: ConfiguredTableAssociationAnalysisRulePolicy,
        analysisRuleType: ConfiguredTableAssociationAnalysisRuleType,
        configuredTableAssociationIdentifier: String,
        membershipIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateConfiguredTableAssociationAnalysisRuleOutput {
        let input = UpdateConfiguredTableAssociationAnalysisRuleInput(
            analysisRulePolicy: analysisRulePolicy, 
            analysisRuleType: analysisRuleType, 
            configuredTableAssociationIdentifier: configuredTableAssociationIdentifier, 
            membershipIdentifier: membershipIdentifier
        )
        return try await self.updateConfiguredTableAssociationAnalysisRule(input, logger: logger)
    }

    /// Provides the details that are necessary to update an ID mapping table.
    @Sendable
    @inlinable
    public func updateIdMappingTable(_ input: UpdateIdMappingTableInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateIdMappingTableOutput {
        try await self.client.execute(
            operation: "UpdateIdMappingTable", 
            path: "/memberships/{membershipIdentifier}/idmappingtables/{idMappingTableIdentifier}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides the details that are necessary to update an ID mapping table.
    ///
    /// Parameters:
    ///   - description: A new description for the ID mapping table.
    ///   - idMappingTableIdentifier: The unique identifier of the ID mapping table that you want to update.
    ///   - kmsKeyArn: The Amazon Resource Name (ARN) of the Amazon Web Services KMS key.
    ///   - membershipIdentifier: The unique identifier of the membership that contains the ID mapping table that you want to update.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateIdMappingTable(
        description: String? = nil,
        idMappingTableIdentifier: String,
        kmsKeyArn: String? = nil,
        membershipIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateIdMappingTableOutput {
        let input = UpdateIdMappingTableInput(
            description: description, 
            idMappingTableIdentifier: idMappingTableIdentifier, 
            kmsKeyArn: kmsKeyArn, 
            membershipIdentifier: membershipIdentifier
        )
        return try await self.updateIdMappingTable(input, logger: logger)
    }

    /// Provides the details that are necessary to update an ID namespace association.
    @Sendable
    @inlinable
    public func updateIdNamespaceAssociation(_ input: UpdateIdNamespaceAssociationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateIdNamespaceAssociationOutput {
        try await self.client.execute(
            operation: "UpdateIdNamespaceAssociation", 
            path: "/memberships/{membershipIdentifier}/idnamespaceassociations/{idNamespaceAssociationIdentifier}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides the details that are necessary to update an ID namespace association.
    ///
    /// Parameters:
    ///   - description: A new description for the ID namespace association.
    ///   - idMappingConfig: The configuration settings for the ID mapping table.
    ///   - idNamespaceAssociationIdentifier: The unique identifier of the ID namespace association that you want to update.
    ///   - membershipIdentifier: The unique identifier of the membership that contains the ID namespace association that you want to update.
    ///   - name: A new name for the ID namespace association.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateIdNamespaceAssociation(
        description: String? = nil,
        idMappingConfig: IdMappingConfig? = nil,
        idNamespaceAssociationIdentifier: String,
        membershipIdentifier: String,
        name: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateIdNamespaceAssociationOutput {
        let input = UpdateIdNamespaceAssociationInput(
            description: description, 
            idMappingConfig: idMappingConfig, 
            idNamespaceAssociationIdentifier: idNamespaceAssociationIdentifier, 
            membershipIdentifier: membershipIdentifier, 
            name: name
        )
        return try await self.updateIdNamespaceAssociation(input, logger: logger)
    }

    /// Updates a membership.
    @Sendable
    @inlinable
    public func updateMembership(_ input: UpdateMembershipInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateMembershipOutput {
        try await self.client.execute(
            operation: "UpdateMembership", 
            path: "/memberships/{membershipIdentifier}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a membership.
    ///
    /// Parameters:
    ///   - defaultJobResultConfiguration:  The default job result configuration.
    ///   - defaultResultConfiguration: The default protected query result configuration as specified by the member who can receive results.
    ///   - jobLogStatus: An indicator as to whether job logging has been enabled or disabled for the collaboration.  When ENABLED, Clean Rooms logs details about jobs run within this collaboration and those logs can be viewed in Amazon CloudWatch Logs. The default value is DISABLED.
    ///   - membershipIdentifier: The unique identifier of the membership.
    ///   - queryLogStatus: An indicator as to whether query logging has been enabled or disabled for the membership. When ENABLED, Clean Rooms logs details about queries run within this collaboration and those logs can be viewed in Amazon CloudWatch Logs. The default value is DISABLED.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateMembership(
        defaultJobResultConfiguration: MembershipProtectedJobResultConfiguration? = nil,
        defaultResultConfiguration: MembershipProtectedQueryResultConfiguration? = nil,
        jobLogStatus: MembershipJobLogStatus? = nil,
        membershipIdentifier: String,
        queryLogStatus: MembershipQueryLogStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateMembershipOutput {
        let input = UpdateMembershipInput(
            defaultJobResultConfiguration: defaultJobResultConfiguration, 
            defaultResultConfiguration: defaultResultConfiguration, 
            jobLogStatus: jobLogStatus, 
            membershipIdentifier: membershipIdentifier, 
            queryLogStatus: queryLogStatus
        )
        return try await self.updateMembership(input, logger: logger)
    }

    /// Updates the privacy budget template for the specified membership.
    @Sendable
    @inlinable
    public func updatePrivacyBudgetTemplate(_ input: UpdatePrivacyBudgetTemplateInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdatePrivacyBudgetTemplateOutput {
        try await self.client.execute(
            operation: "UpdatePrivacyBudgetTemplate", 
            path: "/memberships/{membershipIdentifier}/privacybudgettemplates/{privacyBudgetTemplateIdentifier}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the privacy budget template for the specified membership.
    ///
    /// Parameters:
    ///   - membershipIdentifier: A unique identifier for one of your memberships for a collaboration. The privacy budget template is updated in the collaboration that this membership belongs to. Accepts a membership ID.
    ///   - parameters: Specifies the epsilon and noise parameters for the privacy budget template.
    ///   - privacyBudgetTemplateIdentifier: A unique identifier for your privacy budget template that you want to update.
    ///   - privacyBudgetType: Specifies the type of the privacy budget template.
    ///   - logger: Logger use during operation
    @inlinable
    public func updatePrivacyBudgetTemplate(
        membershipIdentifier: String,
        parameters: PrivacyBudgetTemplateUpdateParameters? = nil,
        privacyBudgetTemplateIdentifier: String,
        privacyBudgetType: PrivacyBudgetType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdatePrivacyBudgetTemplateOutput {
        let input = UpdatePrivacyBudgetTemplateInput(
            membershipIdentifier: membershipIdentifier, 
            parameters: parameters, 
            privacyBudgetTemplateIdentifier: privacyBudgetTemplateIdentifier, 
            privacyBudgetType: privacyBudgetType
        )
        return try await self.updatePrivacyBudgetTemplate(input, logger: logger)
    }

    /// Updates the processing of a currently running job.
    @Sendable
    @inlinable
    public func updateProtectedJob(_ input: UpdateProtectedJobInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateProtectedJobOutput {
        try await self.client.execute(
            operation: "UpdateProtectedJob", 
            path: "/memberships/{membershipIdentifier}/protectedJobs/{protectedJobIdentifier}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the processing of a currently running job.
    ///
    /// Parameters:
    ///   - membershipIdentifier: The identifier for a member of a protected job instance.
    ///   - protectedJobIdentifier:  The identifier of the protected job to update.
    ///   - targetStatus: The target status of a protected job. Used to update the execution status of a currently running job.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateProtectedJob(
        membershipIdentifier: String,
        protectedJobIdentifier: String,
        targetStatus: TargetProtectedJobStatus,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateProtectedJobOutput {
        let input = UpdateProtectedJobInput(
            membershipIdentifier: membershipIdentifier, 
            protectedJobIdentifier: protectedJobIdentifier, 
            targetStatus: targetStatus
        )
        return try await self.updateProtectedJob(input, logger: logger)
    }

    /// Updates the processing of a currently running query.
    @Sendable
    @inlinable
    public func updateProtectedQuery(_ input: UpdateProtectedQueryInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateProtectedQueryOutput {
        try await self.client.execute(
            operation: "UpdateProtectedQuery", 
            path: "/memberships/{membershipIdentifier}/protectedQueries/{protectedQueryIdentifier}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the processing of a currently running query.
    ///
    /// Parameters:
    ///   - membershipIdentifier: The identifier for a member of a protected query instance.
    ///   - protectedQueryIdentifier: The identifier for a protected query instance.
    ///   - targetStatus: The target status of a query. Used to update the execution status of a currently running query.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateProtectedQuery(
        membershipIdentifier: String,
        protectedQueryIdentifier: String,
        targetStatus: TargetProtectedQueryStatus,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateProtectedQueryOutput {
        let input = UpdateProtectedQueryInput(
            membershipIdentifier: membershipIdentifier, 
            protectedQueryIdentifier: protectedQueryIdentifier, 
            targetStatus: targetStatus
        )
        return try await self.updateProtectedQuery(input, logger: logger)
    }
}

extension CleanRooms {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: CleanRooms, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension CleanRooms {
    /// Return PaginatorSequence for operation ``listCollaborationConfiguredAudienceModelAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCollaborationConfiguredAudienceModelAssociationsPaginator(
        _ input: ListCollaborationConfiguredAudienceModelAssociationsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCollaborationConfiguredAudienceModelAssociationsInput, ListCollaborationConfiguredAudienceModelAssociationsOutput> {
        return .init(
            input: input,
            command: self.listCollaborationConfiguredAudienceModelAssociations,
            inputKey: \ListCollaborationConfiguredAudienceModelAssociationsInput.nextToken,
            outputKey: \ListCollaborationConfiguredAudienceModelAssociationsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCollaborationConfiguredAudienceModelAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - collaborationIdentifier: A unique identifier for the collaboration that the configured audience model association belongs to. Accepts a collaboration ID.
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCollaborationConfiguredAudienceModelAssociationsPaginator(
        collaborationIdentifier: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCollaborationConfiguredAudienceModelAssociationsInput, ListCollaborationConfiguredAudienceModelAssociationsOutput> {
        let input = ListCollaborationConfiguredAudienceModelAssociationsInput(
            collaborationIdentifier: collaborationIdentifier, 
            maxResults: maxResults
        )
        return self.listCollaborationConfiguredAudienceModelAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listCollaborationIdNamespaceAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCollaborationIdNamespaceAssociationsPaginator(
        _ input: ListCollaborationIdNamespaceAssociationsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCollaborationIdNamespaceAssociationsInput, ListCollaborationIdNamespaceAssociationsOutput> {
        return .init(
            input: input,
            command: self.listCollaborationIdNamespaceAssociations,
            inputKey: \ListCollaborationIdNamespaceAssociationsInput.nextToken,
            outputKey: \ListCollaborationIdNamespaceAssociationsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCollaborationIdNamespaceAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - collaborationIdentifier: The unique identifier of the collaboration that contains the ID namespace associations that you want to retrieve.
    ///   - maxResults: The maximum size of the results that is returned per call. Service chooses a default if it has not been set. Service may return a nextToken even if the maximum results has not been met.&gt;
    ///   - logger: Logger used for logging
    @inlinable
    public func listCollaborationIdNamespaceAssociationsPaginator(
        collaborationIdentifier: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCollaborationIdNamespaceAssociationsInput, ListCollaborationIdNamespaceAssociationsOutput> {
        let input = ListCollaborationIdNamespaceAssociationsInput(
            collaborationIdentifier: collaborationIdentifier, 
            maxResults: maxResults
        )
        return self.listCollaborationIdNamespaceAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listCollaborationPrivacyBudgetTemplates(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCollaborationPrivacyBudgetTemplatesPaginator(
        _ input: ListCollaborationPrivacyBudgetTemplatesInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCollaborationPrivacyBudgetTemplatesInput, ListCollaborationPrivacyBudgetTemplatesOutput> {
        return .init(
            input: input,
            command: self.listCollaborationPrivacyBudgetTemplates,
            inputKey: \ListCollaborationPrivacyBudgetTemplatesInput.nextToken,
            outputKey: \ListCollaborationPrivacyBudgetTemplatesOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCollaborationPrivacyBudgetTemplates(_:logger:)``.
    ///
    /// - Parameters:
    ///   - collaborationIdentifier: A unique identifier for one of your collaborations.
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCollaborationPrivacyBudgetTemplatesPaginator(
        collaborationIdentifier: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCollaborationPrivacyBudgetTemplatesInput, ListCollaborationPrivacyBudgetTemplatesOutput> {
        let input = ListCollaborationPrivacyBudgetTemplatesInput(
            collaborationIdentifier: collaborationIdentifier, 
            maxResults: maxResults
        )
        return self.listCollaborationPrivacyBudgetTemplatesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listCollaborationPrivacyBudgets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCollaborationPrivacyBudgetsPaginator(
        _ input: ListCollaborationPrivacyBudgetsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCollaborationPrivacyBudgetsInput, ListCollaborationPrivacyBudgetsOutput> {
        return .init(
            input: input,
            command: self.listCollaborationPrivacyBudgets,
            inputKey: \ListCollaborationPrivacyBudgetsInput.nextToken,
            outputKey: \ListCollaborationPrivacyBudgetsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCollaborationPrivacyBudgets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - collaborationIdentifier: A unique identifier for one of your collaborations.
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - privacyBudgetType: Specifies the type of the privacy budget.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCollaborationPrivacyBudgetsPaginator(
        collaborationIdentifier: String,
        maxResults: Int? = nil,
        privacyBudgetType: PrivacyBudgetType,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCollaborationPrivacyBudgetsInput, ListCollaborationPrivacyBudgetsOutput> {
        let input = ListCollaborationPrivacyBudgetsInput(
            collaborationIdentifier: collaborationIdentifier, 
            maxResults: maxResults, 
            privacyBudgetType: privacyBudgetType
        )
        return self.listCollaborationPrivacyBudgetsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listConfiguredAudienceModelAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listConfiguredAudienceModelAssociationsPaginator(
        _ input: ListConfiguredAudienceModelAssociationsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListConfiguredAudienceModelAssociationsInput, ListConfiguredAudienceModelAssociationsOutput> {
        return .init(
            input: input,
            command: self.listConfiguredAudienceModelAssociations,
            inputKey: \ListConfiguredAudienceModelAssociationsInput.nextToken,
            outputKey: \ListConfiguredAudienceModelAssociationsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listConfiguredAudienceModelAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - membershipIdentifier: A unique identifier for a membership that contains the configured audience model associations that you want to retrieve.
    ///   - logger: Logger used for logging
    @inlinable
    public func listConfiguredAudienceModelAssociationsPaginator(
        maxResults: Int? = nil,
        membershipIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListConfiguredAudienceModelAssociationsInput, ListConfiguredAudienceModelAssociationsOutput> {
        let input = ListConfiguredAudienceModelAssociationsInput(
            maxResults: maxResults, 
            membershipIdentifier: membershipIdentifier
        )
        return self.listConfiguredAudienceModelAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listIdMappingTables(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listIdMappingTablesPaginator(
        _ input: ListIdMappingTablesInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListIdMappingTablesInput, ListIdMappingTablesOutput> {
        return .init(
            input: input,
            command: self.listIdMappingTables,
            inputKey: \ListIdMappingTablesInput.nextToken,
            outputKey: \ListIdMappingTablesOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listIdMappingTables(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum size of the results that is returned per call. Service chooses a default if it has not been set. Service may return a nextToken even if the maximum results has not been met.
    ///   - membershipIdentifier: The unique identifier of the membership that contains the ID mapping tables that you want to view.
    ///   - logger: Logger used for logging
    @inlinable
    public func listIdMappingTablesPaginator(
        maxResults: Int? = nil,
        membershipIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListIdMappingTablesInput, ListIdMappingTablesOutput> {
        let input = ListIdMappingTablesInput(
            maxResults: maxResults, 
            membershipIdentifier: membershipIdentifier
        )
        return self.listIdMappingTablesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listIdNamespaceAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listIdNamespaceAssociationsPaginator(
        _ input: ListIdNamespaceAssociationsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListIdNamespaceAssociationsInput, ListIdNamespaceAssociationsOutput> {
        return .init(
            input: input,
            command: self.listIdNamespaceAssociations,
            inputKey: \ListIdNamespaceAssociationsInput.nextToken,
            outputKey: \ListIdNamespaceAssociationsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listIdNamespaceAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum size of the results that is returned per call. Service chooses a default if it has not been set. Service may return a nextToken even if the maximum results has not been met.
    ///   - membershipIdentifier: The unique identifier of the membership that contains the ID namespace association that you want to view.
    ///   - logger: Logger used for logging
    @inlinable
    public func listIdNamespaceAssociationsPaginator(
        maxResults: Int? = nil,
        membershipIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListIdNamespaceAssociationsInput, ListIdNamespaceAssociationsOutput> {
        let input = ListIdNamespaceAssociationsInput(
            maxResults: maxResults, 
            membershipIdentifier: membershipIdentifier
        )
        return self.listIdNamespaceAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listPrivacyBudgetTemplates(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listPrivacyBudgetTemplatesPaginator(
        _ input: ListPrivacyBudgetTemplatesInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListPrivacyBudgetTemplatesInput, ListPrivacyBudgetTemplatesOutput> {
        return .init(
            input: input,
            command: self.listPrivacyBudgetTemplates,
            inputKey: \ListPrivacyBudgetTemplatesInput.nextToken,
            outputKey: \ListPrivacyBudgetTemplatesOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listPrivacyBudgetTemplates(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - membershipIdentifier: A unique identifier for one of your memberships for a collaboration. The privacy budget templates are retrieved from the collaboration that this membership belongs to. Accepts a membership ID.
    ///   - logger: Logger used for logging
    @inlinable
    public func listPrivacyBudgetTemplatesPaginator(
        maxResults: Int? = nil,
        membershipIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListPrivacyBudgetTemplatesInput, ListPrivacyBudgetTemplatesOutput> {
        let input = ListPrivacyBudgetTemplatesInput(
            maxResults: maxResults, 
            membershipIdentifier: membershipIdentifier
        )
        return self.listPrivacyBudgetTemplatesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listPrivacyBudgets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listPrivacyBudgetsPaginator(
        _ input: ListPrivacyBudgetsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListPrivacyBudgetsInput, ListPrivacyBudgetsOutput> {
        return .init(
            input: input,
            command: self.listPrivacyBudgets,
            inputKey: \ListPrivacyBudgetsInput.nextToken,
            outputKey: \ListPrivacyBudgetsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listPrivacyBudgets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - membershipIdentifier: A unique identifier for one of your memberships for a collaboration. The privacy budget is retrieved from the collaboration that this membership belongs to. Accepts a membership ID.
    ///   - privacyBudgetType: The privacy budget type.
    ///   - logger: Logger used for logging
    @inlinable
    public func listPrivacyBudgetsPaginator(
        maxResults: Int? = nil,
        membershipIdentifier: String,
        privacyBudgetType: PrivacyBudgetType,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListPrivacyBudgetsInput, ListPrivacyBudgetsOutput> {
        let input = ListPrivacyBudgetsInput(
            maxResults: maxResults, 
            membershipIdentifier: membershipIdentifier, 
            privacyBudgetType: privacyBudgetType
        )
        return self.listPrivacyBudgetsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listProtectedJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listProtectedJobsPaginator(
        _ input: ListProtectedJobsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListProtectedJobsInput, ListProtectedJobsOutput> {
        return .init(
            input: input,
            command: self.listProtectedJobs,
            inputKey: \ListProtectedJobsInput.nextToken,
            outputKey: \ListProtectedJobsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listProtectedJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - membershipIdentifier: The identifier for the membership in the collaboration.
    ///   - status: A filter on the status of the protected job.
    ///   - logger: Logger used for logging
    @inlinable
    public func listProtectedJobsPaginator(
        maxResults: Int? = nil,
        membershipIdentifier: String,
        status: ProtectedJobStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListProtectedJobsInput, ListProtectedJobsOutput> {
        let input = ListProtectedJobsInput(
            maxResults: maxResults, 
            membershipIdentifier: membershipIdentifier, 
            status: status
        )
        return self.listProtectedJobsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listProtectedQueries(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listProtectedQueriesPaginator(
        _ input: ListProtectedQueriesInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListProtectedQueriesInput, ListProtectedQueriesOutput> {
        return .init(
            input: input,
            command: self.listProtectedQueries,
            inputKey: \ListProtectedQueriesInput.nextToken,
            outputKey: \ListProtectedQueriesOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listProtectedQueries(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results that are returned for an API request call. The service chooses a default number if you don't set one. The service might return a `nextToken` even if the `maxResults` value has not been met.
    ///   - membershipIdentifier: The identifier for the membership in the collaboration.
    ///   - status: A filter on the status of the protected query.
    ///   - logger: Logger used for logging
    @inlinable
    public func listProtectedQueriesPaginator(
        maxResults: Int? = nil,
        membershipIdentifier: String,
        status: ProtectedQueryStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListProtectedQueriesInput, ListProtectedQueriesOutput> {
        let input = ListProtectedQueriesInput(
            maxResults: maxResults, 
            membershipIdentifier: membershipIdentifier, 
            status: status
        )
        return self.listProtectedQueriesPaginator(input, logger: logger)
    }
}

extension CleanRooms.ListCollaborationConfiguredAudienceModelAssociationsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CleanRooms.ListCollaborationConfiguredAudienceModelAssociationsInput {
        return .init(
            collaborationIdentifier: self.collaborationIdentifier,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension CleanRooms.ListCollaborationIdNamespaceAssociationsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CleanRooms.ListCollaborationIdNamespaceAssociationsInput {
        return .init(
            collaborationIdentifier: self.collaborationIdentifier,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension CleanRooms.ListCollaborationPrivacyBudgetTemplatesInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CleanRooms.ListCollaborationPrivacyBudgetTemplatesInput {
        return .init(
            collaborationIdentifier: self.collaborationIdentifier,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension CleanRooms.ListCollaborationPrivacyBudgetsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CleanRooms.ListCollaborationPrivacyBudgetsInput {
        return .init(
            collaborationIdentifier: self.collaborationIdentifier,
            maxResults: self.maxResults,
            nextToken: token,
            privacyBudgetType: self.privacyBudgetType
        )
    }
}

extension CleanRooms.ListConfiguredAudienceModelAssociationsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CleanRooms.ListConfiguredAudienceModelAssociationsInput {
        return .init(
            maxResults: self.maxResults,
            membershipIdentifier: self.membershipIdentifier,
            nextToken: token
        )
    }
}

extension CleanRooms.ListIdMappingTablesInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CleanRooms.ListIdMappingTablesInput {
        return .init(
            maxResults: self.maxResults,
            membershipIdentifier: self.membershipIdentifier,
            nextToken: token
        )
    }
}

extension CleanRooms.ListIdNamespaceAssociationsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CleanRooms.ListIdNamespaceAssociationsInput {
        return .init(
            maxResults: self.maxResults,
            membershipIdentifier: self.membershipIdentifier,
            nextToken: token
        )
    }
}

extension CleanRooms.ListPrivacyBudgetTemplatesInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CleanRooms.ListPrivacyBudgetTemplatesInput {
        return .init(
            maxResults: self.maxResults,
            membershipIdentifier: self.membershipIdentifier,
            nextToken: token
        )
    }
}

extension CleanRooms.ListPrivacyBudgetsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CleanRooms.ListPrivacyBudgetsInput {
        return .init(
            maxResults: self.maxResults,
            membershipIdentifier: self.membershipIdentifier,
            nextToken: token,
            privacyBudgetType: self.privacyBudgetType
        )
    }
}

extension CleanRooms.ListProtectedJobsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CleanRooms.ListProtectedJobsInput {
        return .init(
            maxResults: self.maxResults,
            membershipIdentifier: self.membershipIdentifier,
            nextToken: token,
            status: self.status
        )
    }
}

extension CleanRooms.ListProtectedQueriesInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CleanRooms.ListProtectedQueriesInput {
        return .init(
            maxResults: self.maxResults,
            membershipIdentifier: self.membershipIdentifier,
            nextToken: token,
            status: self.status
        )
    }
}
